├── .gitignore
├── Android
    ├── .gitignore
    ├── app
    │   ├── .gitignore
    │   ├── build.gradle
    │   ├── proguard-rules.pro
    │   └── src
    │   │   └── main
    │   │       ├── AndroidManifest.xml
    │   │       ├── java
    │   │           └── mgf
    │   │           │   └── android
    │   │           │       └── GXActivity.java
    │   │       └── res
    │   │           ├── mipmap-hdpi
    │   │               └── ic_launcher.png
    │   │           ├── mipmap-mdpi
    │   │               └── ic_launcher.png
    │   │           ├── mipmap-xhdpi
    │   │               └── ic_launcher.png
    │   │           ├── mipmap-xxhdpi
    │   │               └── ic_launcher.png
    │   │           ├── mipmap-xxxhdpi
    │   │               └── ic_launcher.png
    │   │           └── values
    │   │               ├── colors.xml
    │   │               ├── strings.xml
    │   │               └── styles.xml
    ├── build.gradle
    ├── gradle.properties
    ├── gradlew
    ├── gradlew.bat
    └── settings.gradle
├── CMakeLists.txt
├── Core
    ├── CMakeLists.txt
    ├── Config
    │   ├── Engine.Config.h
    │   ├── Engine.Version.h
    │   ├── Main.cpp
    │   └── STL.Config.h
    ├── Java
    │   ├── Java.cpp
    │   ├── JavaArray.h
    │   ├── JavaClass.h
    │   ├── JavaEnvironment.h
    │   ├── JavaMethod.h
    │   ├── JavaMethodType.h
    │   ├── JavaString.h
    │   └── JavaTypeInfo.h
    ├── Physics
    │   ├── Algorithms
    │   │   ├── AcceleratedMotion.h
    │   │   ├── Astrophysics.h
    │   │   └── Astrophysics_Orbit.h
    │   ├── Common
    │   │   ├── Common.h
    │   │   └── Main.cpp
    │   ├── CompileTime
    │   │   ├── GenType.h
    │   │   └── PhysTypeInfo.h
    │   ├── Core.Physics.h
    │   └── Dimensions
    │   │   ├── AstrophysicsConstants.h
    │   │   ├── DefaultTypes.h
    │   │   ├── PhysicsConstants.h
    │   │   ├── PhysicsDimension.h
    │   │   ├── PhysicsValue.h
    │   │   ├── PhysicsValueMath.h
    │   │   ├── PhysicsValueUtils.h
    │   │   ├── PhysicsValueVec.h
    │   │   └── PhysicsValueVecI.h
    ├── README.md
    ├── STL
    │   ├── Algorithms
    │   │   ├── ArrayUtils.h
    │   │   ├── Comparators.h
    │   │   ├── Crypt
    │   │   │   └── SimpleCrypt.h
    │   │   ├── Enum.h
    │   │   ├── FileAddress.cpp
    │   │   ├── FileAddress.h
    │   │   ├── Filters
    │   │   │   └── GaussianFilter.h
    │   │   ├── Hash.h
    │   │   ├── InvokeWithVariant.h
    │   │   ├── Range.h
    │   │   ├── Sorts.h
    │   │   ├── StringParser.cpp
    │   │   ├── StringParser.h
    │   │   ├── StringUtils.h
    │   │   └── Swap.h
    │   ├── Common
    │   │   ├── AllFunc.h
    │   │   ├── Cast.h
    │   │   ├── Compilers
    │   │   │   ├── CompilerClang.h
    │   │   │   ├── CompilerGCC.h
    │   │   │   └── CompilerMSVC.h
    │   │   ├── Init.h
    │   │   ├── Main.cpp
    │   │   ├── Platforms.h
    │   │   ├── TypeId.h
    │   │   ├── Types.h
    │   │   ├── UMax.h
    │   │   └── Uninitialized.h
    │   ├── CompileTime
    │   │   ├── CompileTimeChecks.h
    │   │   ├── CompileTimeDebug.h
    │   │   ├── CompileTimeTypes.h
    │   │   ├── DeferredTemplates.h
    │   │   ├── FunctionInfo.h
    │   │   ├── Map.h
    │   │   ├── NearType.h
    │   │   ├── NewTypeInfo.h
    │   │   ├── OldTypeInfo.h
    │   │   ├── PlainOldDataType.h
    │   │   ├── Runtime
    │   │   │   └── TypeIdList.h
    │   │   ├── Sequence.h
    │   │   ├── StaticFloat.h
    │   │   ├── StaticFractional.h
    │   │   ├── StaticInteger.h
    │   │   ├── StringToID.h
    │   │   ├── TemplateMath.h
    │   │   ├── TemplateUtils.h
    │   │   ├── TypeInfoFunc.h
    │   │   ├── TypeList.h
    │   │   ├── TypeListHelpers.h
    │   │   ├── TypeListUtils.h
    │   │   ├── TypeQualifier.h
    │   │   └── TypeTraits.h
    │   ├── Compression
    │   │   ├── Compression.h
    │   │   ├── LZ4Compression.h
    │   │   └── MiniZCompression.h
    │   ├── Containers
    │   │   ├── Adaptors.h
    │   │   ├── AppendableAdaptor.h
    │   │   ├── Array.h
    │   │   ├── ArrayRef.h
    │   │   ├── CircularQueue.h
    │   │   ├── CopyStrategy.h
    │   │   ├── Deque.h
    │   │   ├── ErasableAdaptor.h
    │   │   ├── HashMap.h
    │   │   ├── HashSet.h
    │   │   ├── IndexedArray.h
    │   │   ├── IndexedIterator.h
    │   │   ├── Map.h
    │   │   ├── MapUtils.h
    │   │   ├── Pair.h
    │   │   ├── Queue.h
    │   │   ├── Set.h
    │   │   ├── Stack.h
    │   │   ├── StaticArray.h
    │   │   ├── StaticBitArray.h
    │   │   ├── String.h
    │   │   ├── StringRef.h
    │   │   ├── Tuple.h
    │   │   └── UniBuffer.h
    │   ├── Core.STL.h
    │   ├── DataBase
    │   │   ├── SimpleDB.h
    │   │   ├── Utf8StringUtils.cpp
    │   │   └── Utf8StringUtils.h
    │   ├── Defines
    │   │   ├── AuxiliaryDefines.h
    │   │   ├── CtorHelpers.h
    │   │   ├── Defines.h
    │   │   ├── EnumHelpers.h
    │   │   ├── Errors.h
    │   │   ├── MemberDetector.h
    │   │   ├── OperatorHelpers.h
    │   │   └── PublicMacro.h
    │   ├── Dimensions
    │   │   ├── ByteAndBit.h
    │   │   ├── Percentage.h
    │   │   ├── PowerOfTwoValue.h
    │   │   └── RadiansAndDegrees.h
    │   ├── Files
    │   │   ├── BaseFile.h
    │   │   ├── CryptFile.h
    │   │   ├── HDDFile.h
    │   │   ├── LzmaFile.h
    │   │   ├── MemFile.h
    │   │   ├── SubFile.h
    │   │   └── ZipFile.h
    │   ├── Log
    │   │   ├── ELog.h
    │   │   ├── Logger.cpp
    │   │   ├── Logger.h
    │   │   └── ToString.h
    │   ├── Math
    │   │   ├── 2D
    │   │   │   ├── Circle.h
    │   │   │   ├── Line2.h
    │   │   │   ├── MathTypes2D.h
    │   │   │   ├── OrientedRectangle.h
    │   │   │   └── Rectangle.h
    │   │   ├── 3D
    │   │   │   ├── AxisAlignedBox.h
    │   │   │   ├── CoordTransform3.h
    │   │   │   ├── Frustum.h
    │   │   │   ├── Line3.h
    │   │   │   ├── MathTypes3D.h
    │   │   │   ├── PerspectiveCamera.h
    │   │   │   ├── Plane.h
    │   │   │   ├── Transform.h
    │   │   │   └── Triangle.h
    │   │   ├── Algebra.h
    │   │   ├── BinaryMath.h
    │   │   ├── Color
    │   │   │   ├── Color.h
    │   │   │   ├── ColorFormats.h
    │   │   │   ├── Half.h
    │   │   │   ├── TR11G11B10F.h
    │   │   │   └── TRGB9_E5.h
    │   │   ├── FastMath.h
    │   │   ├── Image
    │   │   │   └── ImageUtils.h
    │   │   ├── Interpolations.h
    │   │   ├── MathConstants.h
    │   │   ├── MathFunc.h
    │   │   ├── MathTypeCast.h
    │   │   ├── MathTypes.h
    │   │   ├── Mathematics.h
    │   │   ├── Matrix.h
    │   │   ├── Matrix2.h
    │   │   ├── Matrix3.h
    │   │   ├── Matrix4.h
    │   │   ├── MatrixCR.h
    │   │   ├── MatrixUtils.h
    │   │   ├── OverflowCheck.h
    │   │   ├── Quaternion.h
    │   │   ├── Rand
    │   │   │   ├── NormalDistribution.h
    │   │   │   ├── Pseudorandom.h
    │   │   │   ├── RandEngine.h
    │   │   │   ├── Random.h
    │   │   │   └── RandomWithChance.h
    │   │   ├── Spline
    │   │   │   └── Spline.h
    │   │   ├── Trigonometry.h
    │   │   ├── Vec.h
    │   │   └── VecI.h
    │   ├── Memory
    │   │   ├── Allocators.h
    │   │   ├── MemFunc.h
    │   │   ├── MemoryContainer.h
    │   │   ├── MemoryViewer.h
    │   │   └── PlacementNew.h
    │   ├── OS
    │   │   ├── Android
    │   │   │   └── OSAndroid.h
    │   │   ├── Base
    │   │   │   ├── BaseFileSystem.cpp
    │   │   │   ├── BaseFileSystem.h
    │   │   │   ├── Common.h
    │   │   │   ├── ConditionVariableEmulation.h
    │   │   │   ├── Date.cpp
    │   │   │   ├── Date.h
    │   │   │   ├── Endianes.h
    │   │   │   ├── ReadWriteSyncEmulation.h
    │   │   │   ├── ScopeLock.h
    │   │   │   ├── SemaphoreEmulator.h
    │   │   │   └── SyncEventEmulation.h
    │   │   ├── OSLowLevel.h
    │   │   ├── Posix
    │   │   │   ├── OSPosix.h
    │   │   │   ├── PosixFileSystem.cpp
    │   │   │   ├── PosixFileSystem.h
    │   │   │   ├── PosixHeader.h
    │   │   │   ├── PosixLibrary.cpp
    │   │   │   ├── PosixLibrary.h
    │   │   │   ├── PosixPlatformUtils.h
    │   │   │   ├── PosixRandDevice.cpp
    │   │   │   ├── PosixRandDevice.h
    │   │   │   ├── PosixSyncPrimitives.cpp
    │   │   │   ├── PosixSyncPrimitives.h
    │   │   │   ├── PosixThread.cpp
    │   │   │   ├── PosixThread.h
    │   │   │   ├── PosixTimer.cpp
    │   │   │   └── PosixTimer.h
    │   │   ├── SDL
    │   │   │   ├── OS_SDL.h
    │   │   │   ├── SDLFileSystem.h
    │   │   │   ├── SDLLibrary.cpp
    │   │   │   ├── SDLLibrary.h
    │   │   │   ├── SDLPlatformUtils.cpp
    │   │   │   ├── SDLPlatformUtils.h
    │   │   │   ├── SDLRandDevice.h
    │   │   │   ├── SDLSyncPrimitives.cpp
    │   │   │   ├── SDLSyncPrimitives.h
    │   │   │   ├── SDLThread.cpp
    │   │   │   ├── SDLThread.h
    │   │   │   └── SDLTimer.h
    │   │   ├── STD
    │   │   │   ├── STDSyncPrimitives.h
    │   │   │   ├── STDThread.cpp
    │   │   │   ├── STDThread.h
    │   │   │   └── STDTimer.h
    │   │   └── Windows
    │   │   │   ├── OSWindows.h
    │   │   │   ├── WinFileSystem.cpp
    │   │   │   ├── WinFileSystem.h
    │   │   │   ├── WinHeader.h
    │   │   │   ├── WinLibrary.cpp
    │   │   │   ├── WinLibrary.h
    │   │   │   ├── WinPlatformUtils.cpp
    │   │   │   ├── WinPlatformUtils.h
    │   │   │   ├── WinRandDevice.cpp
    │   │   │   ├── WinRandDevice.h
    │   │   │   ├── WinSyncPrimitives.cpp
    │   │   │   ├── WinSyncPrimitives.h
    │   │   │   ├── WinThread.cpp
    │   │   │   ├── WinThread.h
    │   │   │   ├── WinTimer.cpp
    │   │   │   └── WinTimer.h
    │   ├── ThreadSafe
    │   │   ├── Atomic.h
    │   │   ├── AtomicBitfield.h
    │   │   ├── AtomicCounter.h
    │   │   ├── AtomicFlag.h
    │   │   ├── MtFile.h
    │   │   ├── MtQueue.h
    │   │   └── Singleton.h
    │   ├── Time
    │   │   ├── FloatTimeImpl.h
    │   │   ├── IntTimeImpl.h
    │   │   ├── Time.h
    │   │   └── TimeProfiler.h
    │   └── Types
    │   │   ├── Bitfield.h
    │   │   ├── Bool.h
    │   │   ├── DefferedType.h
    │   │   ├── Delegate.h
    │   │   ├── Function.h
    │   │   ├── Limit.h
    │   │   ├── Noncopyable.h
    │   │   ├── Noninstancable.h
    │   │   ├── Optional.h
    │   │   ├── Ptr.h
    │   │   ├── RefCountedObject.h
    │   │   ├── RefCounter.h
    │   │   ├── ScopeSetter.h
    │   │   ├── SharedPointer.h
    │   │   ├── StaticLimit.h
    │   │   ├── StaticRefCountedObject.h
    │   │   ├── Union.h
    │   │   ├── UniquePtr.h
    │   │   ├── UntypedKey.h
    │   │   ├── VariantCRef.h
    │   │   ├── VariantInterface.h
    │   │   ├── VariantRef.h
    │   │   ├── VariantRefIndexedContainer.h
    │   │   └── WeakPointer.h
    ├── Script
    │   ├── Bindings
    │   │   ├── BindScalarMath.cpp
    │   │   ├── BindString.cpp
    │   │   ├── BindVectorMath.cpp
    │   │   └── DefaultBindings.h
    │   ├── Core.Script.h
    │   └── Impl
    │   │   ├── ClassBinder.h
    │   │   ├── EnumBinder.h
    │   │   ├── ScriptBinder.cpp
    │   │   ├── ScriptEngine.cpp
    │   │   ├── ScriptEngine.h
    │   │   ├── ScriptEngine.inl.h
    │   │   ├── ScriptModule.cpp
    │   │   ├── ScriptModule.h
    │   │   └── ScriptTypes.h
    └── compilers.cmake
├── CoreTests
    ├── Physics
    │   ├── Common.h
    │   ├── Main.cpp
    │   ├── Test_Algorithms_Orbit.cpp
    │   └── Test_Dimensions_PhysicsValue.cpp
    ├── STL
    │   ├── Common.h
    │   ├── Debug.h
    │   ├── Main.cpp
    │   ├── Test_Algorithms_InvokeWithVariant.cpp
    │   ├── Test_Algorithms_Range.cpp
    │   ├── Test_CompileTime_MainType.cpp
    │   ├── Test_CompileTime_Map.cpp
    │   ├── Test_CompileTime_Sequence.cpp
    │   ├── Test_CompileTime_StaticFloat.cpp
    │   ├── Test_CompileTime_StringToID.cpp
    │   ├── Test_CompileTime_TemplateMath.cpp
    │   ├── Test_CompileTime_TypeInfo.cpp
    │   ├── Test_CompileTime_TypeList.cpp
    │   ├── Test_CompileTime_TypeQualifier.cpp
    │   ├── Test_CompileTime_TypeTraits.cpp
    │   ├── Test_Containers_Adaptors.cpp
    │   ├── Test_Containers_Array.cpp
    │   ├── Test_Containers_CircularQueue.cpp
    │   ├── Test_Containers_Deque.cpp
    │   ├── Test_Containers_HashSet.cpp
    │   ├── Test_Containers_IndexedArray.cpp
    │   ├── Test_Containers_List.cpp
    │   ├── Test_Containers_Map.cpp
    │   ├── Test_Containers_Queue.cpp
    │   ├── Test_Containers_Set.cpp
    │   ├── Test_Containers_String.cpp
    │   ├── Test_Containers_Tuple.cpp
    │   ├── Test_Math_Abs.cpp
    │   ├── Test_Math_Bit.cpp
    │   ├── Test_Math_Clamp_Wrap.cpp
    │   ├── Test_Math_Color.cpp
    │   ├── Test_Math_ColorFormat.cpp
    │   ├── Test_Math_Factorial.cpp
    │   ├── Test_Math_FloorCeilTruncRoundFract.cpp
    │   ├── Test_Math_Frustum.cpp
    │   ├── Test_Math_ImageUtils.cpp
    │   ├── Test_Math_Matrix.cpp
    │   ├── Test_Math_OverflowCheck.cpp
    │   ├── Test_Math_Plane.cpp
    │   ├── Test_Math_Transform.cpp
    │   ├── Test_OS_Atomic.cpp
    │   ├── Test_OS_Date.cpp
    │   ├── Test_OS_FileSystem.cpp
    │   ├── Test_Runtime_VirtualTypelist.cpp
    │   ├── Test_Temp.cpp
    │   ├── Test_Type_Optional.cpp
    │   ├── Test_Types_Cast.cpp
    │   ├── Test_Types_FileAddress.cpp
    │   ├── Test_Types_Function.cpp
    │   ├── Test_Types_StringParser.cpp
    │   ├── Test_Types_Time.cpp
    │   └── Test_Types_Union.cpp
    └── Script
    │   ├── Common.h
    │   ├── Main.cpp
    │   ├── Test_Eval.cpp
    │   ├── Test_ScriptClass.cpp
    │   ├── Test_ScriptScalarMath.cpp
    │   ├── Test_ScriptString.cpp
    │   └── Test_ScriptVectorMath.cpp
├── Engine
    ├── Base
    │   ├── Common
    │   │   ├── BaseObject.h
    │   │   ├── Common.h
    │   │   ├── Defines.h
    │   │   ├── EModuleGroup.h
    │   │   ├── EngineSubSystems.h
    │   │   ├── Enums.h
    │   │   ├── IDs.h
    │   │   └── ThreadID.h
    │   ├── DataProvider
    │   │   ├── BuiltinStorageDataProvider.cpp
    │   │   ├── DataMessages.h
    │   │   ├── DataProviderManager.cpp
    │   │   ├── DataProviderObjectsConstructor.cpp
    │   │   ├── DataProviderObjectsConstructor.h
    │   │   ├── FileDataInput.cpp
    │   │   ├── FileDataOutput.cpp
    │   │   ├── FileInputStream.cpp
    │   │   ├── FileOutputStream.cpp
    │   │   ├── InMemoryDataProvider.cpp
    │   │   ├── InternetDataProvider.cpp
    │   │   └── LocalStorageDataProvider.cpp
    │   ├── Engine.Base.h
    │   ├── Main
    │   │   ├── MainSystem.cpp
    │   │   └── MainSystem.h
    │   ├── Modules
    │   │   ├── MessageCache.h
    │   │   ├── MessageHandler.cpp
    │   │   ├── MessageHandler.h
    │   │   ├── MessageHelpers.h
    │   │   ├── Module.Send.inl.h
    │   │   ├── Module.cpp
    │   │   ├── Module.h
    │   │   ├── Module.inl.h
    │   │   ├── ModuleAsyncTasks.h
    │   │   ├── ModuleUtils.h
    │   │   ├── ModulesFactory.cpp
    │   │   └── ModulesFactory.h
    │   ├── Public
    │   │   ├── AsyncMessage.h
    │   │   ├── CreateInfo.h
    │   │   ├── DataProvider.h
    │   │   ├── ModuleMessages.h
    │   │   ├── ParallelThread.h
    │   │   ├── ProfilingMessages.h
    │   │   └── TaskModule.h
    │   ├── Tasks
    │   │   ├── AsyncTask.h
    │   │   ├── TaskManager.cpp
    │   │   ├── TaskManager.h
    │   │   └── TaskModule.cpp
    │   └── Threads
    │   │   ├── ParallelThreadImpl.cpp
    │   │   ├── ParallelThreadImpl.h
    │   │   ├── ThreadManager.cpp
    │   │   └── ThreadManager.h
    ├── CMakeLists.txt
    ├── Graphics
    │   ├── Engine.Graphics.h
    │   ├── Impl
    │   │   ├── AsyncCommandBuffer.cpp
    │   │   ├── BatchRenderer.cpp
    │   │   ├── CommandBufferManager.cpp
    │   │   ├── Font.cpp
    │   │   ├── FontManager.cpp
    │   │   ├── GraphicsBaseModule.cpp
    │   │   ├── GraphicsBaseModule.h
    │   │   ├── GraphicsObjectsConstructor.h
    │   │   ├── Main.cpp
    │   │   └── TextureLineAtlas.h
    │   └── Public
    │   │   ├── BatchRenderer.h
    │   │   ├── Commands.h
    │   │   ├── Common.h
    │   │   ├── Font.h
    │   │   ├── IDs.h
    │   │   ├── Primitives.h
    │   │   └── Vertices.h
    ├── ImportExport
    │   ├── Engine.ImportExport.h
    │   ├── Impl
    │   │   ├── GX_ImageFormat.h
    │   │   ├── GX_ImageLoader.cpp
    │   │   ├── GX_ImageSaver.cpp
    │   │   ├── ImportExportObjectsConstructor.h
    │   │   └── Main.cpp
    │   ├── Public
    │   │   ├── Common.h
    │   │   ├── IDs.h
    │   │   └── Image.h
    │   └── README.md
    ├── PipelineCompiler
    │   ├── Common
    │   │   ├── ArraySize.h
    │   │   ├── Common.h
    │   │   ├── Packing.h
    │   │   ├── ShaderEnums.h
    │   │   └── ToGLSL.h
    │   ├── Pipelines
    │   │   ├── BasePipeline.cpp
    │   │   ├── BasePipeline.h
    │   │   ├── BasePipeline_Pass1.cpp
    │   │   ├── BasePipeline_Pass2.cpp
    │   │   ├── ComputePipeline.cpp
    │   │   ├── ComputePipeline.h
    │   │   ├── GraphicsPipeline.cpp
    │   │   ├── GraphicsPipeline.h
    │   │   ├── PipelineManager.cpp
    │   │   └── PipelineManager.h
    │   ├── README.md
    │   ├── Serializers
    │   │   ├── AngelScriptSerializer.cpp
    │   │   ├── AngelScriptSerializer.h
    │   │   ├── CppSerializer.cpp
    │   │   ├── CppSerializer.h
    │   │   └── ISerializer.h
    │   ├── Shaders
    │   │   ├── DeserializedShader.cpp
    │   │   ├── DeserializedShader.h
    │   │   ├── ShaderCompiler.cpp
    │   │   ├── ShaderCompiler.h
    │   │   ├── ShaderCompiler_CLCompiler.cpp
    │   │   ├── ShaderCompiler_CLTranslator.cpp
    │   │   ├── ShaderCompiler_CPPTranslator.cpp
    │   │   ├── ShaderCompiler_GLCompiler.cpp
    │   │   ├── ShaderCompiler_GLParser.cpp
    │   │   ├── ShaderCompiler_GLSLTranslator.cpp
    │   │   ├── ShaderCompiler_HLSLCompiler.cpp
    │   │   ├── ShaderCompiler_HLSLTranslator.cpp
    │   │   ├── ShaderCompiler_Includer.cpp
    │   │   ├── ShaderCompiler_Includer.h
    │   │   ├── ShaderCompiler_NameValidator.cpp
    │   │   ├── ShaderCompiler_NameValidator.h
    │   │   ├── ShaderCompiler_ReplaceTypes.cpp
    │   │   ├── ShaderCompiler_Translator.cpp
    │   │   ├── ShaderCompiler_Translator.h
    │   │   ├── ShaderCompiler_Utils.h
    │   │   ├── ShaderCompiler_VkCompiler.cpp
    │   │   └── glslang_Include.h
    │   ├── cl
    │   │   ├── cl_source_vfs.cpp
    │   │   ├── cl_source_vfs.h
    │   │   ├── funcs.cpp
    │   │   ├── matrix.cpp
    │   │   └── vload.cpp
    │   ├── glsl
    │   │   ├── AABBox.cpp
    │   │   ├── Billow.cpp
    │   │   ├── BitMath.cpp
    │   │   ├── Blur.cpp
    │   │   ├── Cellular.cpp
    │   │   ├── Cmp.cpp
    │   │   ├── Color.cpp
    │   │   ├── Colors.cpp
    │   │   ├── DHash.cpp
    │   │   ├── DefaultSDF.cpp
    │   │   ├── Defines.cpp
    │   │   ├── Emitters.cpp
    │   │   ├── FBM.cpp
    │   │   ├── Gabor.cpp
    │   │   ├── GlobalIndex.cpp
    │   │   ├── Gravity.cpp
    │   │   ├── Hash.cpp
    │   │   ├── Hash2.cpp
    │   │   ├── IHash.cpp
    │   │   ├── Line2.cpp
    │   │   ├── Line3.cpp
    │   │   ├── Magnetism.cpp
    │   │   ├── Math.cpp
    │   │   ├── MathDef.cpp
    │   │   ├── Matrix.cpp
    │   │   ├── Perlin.cpp
    │   │   ├── Plane.cpp
    │   │   ├── Quaternion.cpp
    │   │   ├── Ray.cpp
    │   │   ├── Rect.cpp
    │   │   ├── Simplex.cpp
    │   │   ├── Turbulence.cpp
    │   │   ├── TypeInfo.cpp
    │   │   ├── Utils.cpp
    │   │   ├── Voronoi.cpp
    │   │   ├── VoronoiLines.cpp
    │   │   ├── VoronoiNoise.cpp
    │   │   ├── _NoiseUtils.cpp
    │   │   ├── glsl_source_vfs.cpp
    │   │   └── glsl_source_vfs.h
    │   └── hlsl
    │   │   ├── hlsl_source_vfs.cpp
    │   │   ├── hlsl_source_vfs.h
    │   │   └── vload.cpp
    ├── Platforms
    │   ├── Engine.Platforms.h
    │   ├── Impl
    │   │   ├── Main.cpp
    │   │   └── PipelineTemplate.cpp
    │   ├── Input
    │   │   ├── InputManager.cpp
    │   │   ├── InputManager.h
    │   │   └── InputThread.cpp
    │   ├── OpenCL
    │   │   ├── 120
    │   │   │   ├── CL1BaseModule.cpp
    │   │   │   ├── CL1BaseModule.h
    │   │   │   ├── CL1Buffer.cpp
    │   │   │   ├── CL1CommandBuffer.cpp
    │   │   │   ├── CL1CommandBuilder.cpp
    │   │   │   ├── CL1CommandQueue.cpp
    │   │   │   ├── CL1Device.cpp
    │   │   │   ├── CL1Device.h
    │   │   │   ├── CL1Emulator.cpp
    │   │   │   ├── CL1Emulator.h
    │   │   │   ├── CL1Enums.h
    │   │   │   ├── CL1Image.cpp
    │   │   │   ├── CL1Messages.h
    │   │   │   ├── CL1Pipeline.cpp
    │   │   │   ├── CL1PipelineResourceTable.cpp
    │   │   │   ├── CL1ResourceCache.h
    │   │   │   ├── CL1Sampler.cpp
    │   │   │   ├── CL1SamplerCache.h
    │   │   │   ├── CL1SyncManager.cpp
    │   │   │   ├── cl2.cpp
    │   │   │   └── cl2.h
    │   │   ├── OpenCLContext.cpp
    │   │   ├── OpenCLObjectsConstructor.h
    │   │   └── OpenCLThread.cpp
    │   ├── OpenGL
    │   │   ├── 450
    │   │   │   ├── GL4BaseModule.cpp
    │   │   │   ├── GL4BaseModule.h
    │   │   │   ├── GL4Buffer.cpp
    │   │   │   ├── GL4CommandBuffer.cpp
    │   │   │   ├── GL4CommandBuilder.cpp
    │   │   │   ├── GL4CommandQueue.cpp
    │   │   │   ├── GL4Device.cpp
    │   │   │   ├── GL4Device.h
    │   │   │   ├── GL4Emulator.h
    │   │   │   ├── GL4Enums.h
    │   │   │   ├── GL4FlippedSystemFramebuffer.h
    │   │   │   ├── GL4Framebuffer.cpp
    │   │   │   ├── GL4Image.cpp
    │   │   │   ├── GL4Memory.cpp
    │   │   │   ├── GL4Messages.h
    │   │   │   ├── GL4Pipeline.cpp
    │   │   │   ├── GL4PipelineResourceTable.cpp
    │   │   │   ├── GL4QueryPool.cpp
    │   │   │   ├── GL4RenderPass.cpp
    │   │   │   ├── GL4ResourceCache.h
    │   │   │   ├── GL4Sampler.cpp
    │   │   │   ├── GL4SamplerCache.h
    │   │   │   ├── GL4SyncManager.cpp
    │   │   │   ├── GL4SystemFramebuffer.h
    │   │   │   ├── gl4.cpp
    │   │   │   └── gl4.h
    │   │   ├── 300es
    │   │   │   ├── gles3.cpp
    │   │   │   └── gles3.h
    │   │   ├── EGL
    │   │   │   ├── EGLRenderContext.cpp
    │   │   │   └── EGLRenderContext.h
    │   │   ├── Linux
    │   │   │   ├── GLX11Context.cpp
    │   │   │   ├── GLX11Context.h
    │   │   │   ├── GLX11Library.cpp
    │   │   │   └── GLX11Library.h
    │   │   ├── OpenGLContext.cpp
    │   │   ├── OpenGLObjectsConstructor.h
    │   │   ├── OpenGLThread.cpp
    │   │   └── Windows
    │   │   │   ├── GLWinContext.cpp
    │   │   │   ├── GLWinContext.h
    │   │   │   ├── GLWinLibrary.cpp
    │   │   │   └── GLWinLibrary.h
    │   ├── Public
    │   │   ├── Common.h
    │   │   ├── GPU
    │   │   │   ├── Buffer.h
    │   │   │   ├── BufferEnums.h
    │   │   │   ├── CommandBuffer.h
    │   │   │   ├── CommandEnums.h
    │   │   │   ├── CommandQueue.h
    │   │   │   ├── Context.cpp
    │   │   │   ├── Context.h
    │   │   │   ├── Enums.ToString.h
    │   │   │   ├── FragmentOutputState.h
    │   │   │   ├── Framebuffer.cpp
    │   │   │   ├── Framebuffer.h
    │   │   │   ├── IDs.h
    │   │   │   ├── Image.cpp
    │   │   │   ├── Image.h
    │   │   │   ├── ImageEnums.h
    │   │   │   ├── ImageLayer.h
    │   │   │   ├── ImageSwizzle.h
    │   │   │   ├── Memory.h
    │   │   │   ├── MemoryEnums.h
    │   │   │   ├── MipmapLevel.h
    │   │   │   ├── MultiSamples.h
    │   │   │   ├── ObjectEnums.h
    │   │   │   ├── Pipeline.cpp
    │   │   │   ├── Pipeline.h
    │   │   │   ├── PipelineLayout.cpp
    │   │   │   ├── PipelineLayout.h
    │   │   │   ├── PixelFormatEnums.h
    │   │   │   ├── Query.h
    │   │   │   ├── QueryEnums.h
    │   │   │   ├── RenderPass.cpp
    │   │   │   ├── RenderPass.h
    │   │   │   ├── RenderPassEnums.h
    │   │   │   ├── RenderState.cpp
    │   │   │   ├── RenderState.h
    │   │   │   ├── RenderStateEnums.h
    │   │   │   ├── Sampler.cpp
    │   │   │   ├── Sampler.h
    │   │   │   ├── SamplerEnums.h
    │   │   │   ├── ShaderEnums.h
    │   │   │   ├── Sync.h
    │   │   │   ├── Thread.h
    │   │   │   ├── VR.h
    │   │   │   ├── VertexAttribs.h
    │   │   │   ├── VertexDescr.h
    │   │   │   ├── VertexEnums.h
    │   │   │   ├── VertexInputState.cpp
    │   │   │   └── VertexInputState.h
    │   │   ├── OS
    │   │   │   ├── Display.h
    │   │   │   ├── IDs.h
    │   │   │   ├── Input.h
    │   │   │   ├── OSEnums.h
    │   │   │   ├── Platform.h
    │   │   │   ├── ScreenCoords.h
    │   │   │   └── Window.h
    │   │   └── Tools
    │   │   │   ├── AsyncCommandsEmulator.h
    │   │   │   ├── GPUThreadHelper.cpp
    │   │   │   ├── GPUThreadHelper.h
    │   │   │   ├── ImageUtils.cpp
    │   │   │   ├── ImageUtils.h
    │   │   │   ├── ImageViewHashMap.h
    │   │   │   ├── MemoryMapperHelper.cpp
    │   │   │   ├── MemoryMapperHelper.h
    │   │   │   ├── SamplerUtils.cpp
    │   │   │   ├── SamplerUtils.h
    │   │   │   ├── WindowHelper.cpp
    │   │   │   └── WindowHelper.h
    │   ├── SDL
    │   │   ├── SDLDisplay.cpp
    │   │   ├── SDLDisplay.h
    │   │   ├── SDLKeyInput.cpp
    │   │   ├── SDLMessages.h
    │   │   ├── SDLMouseInput.cpp
    │   │   ├── SDLObjectsConstructor.h
    │   │   ├── SDLPlatform.cpp
    │   │   └── SDLWindow.cpp
    │   ├── Soft
    │   │   ├── Android
    │   │   │   ├── SwAndSurface.cpp
    │   │   │   └── SwAndSurface.h
    │   │   ├── Impl
    │   │   │   ├── SWBaseModule.cpp
    │   │   │   ├── SWBaseModule.h
    │   │   │   ├── SWBuffer.cpp
    │   │   │   ├── SWCommandBuffer.cpp
    │   │   │   ├── SWCommandBuilder.cpp
    │   │   │   ├── SWCommandQueue.cpp
    │   │   │   ├── SWDevice.cpp
    │   │   │   ├── SWDevice.h
    │   │   │   ├── SWDeviceProperties.h
    │   │   │   ├── SWEnums.h
    │   │   │   ├── SWImage.cpp
    │   │   │   ├── SWMemory.cpp
    │   │   │   ├── SWMessages.h
    │   │   │   ├── SWPipeline.cpp
    │   │   │   ├── SWPipelineResourceTable.cpp
    │   │   │   ├── SWSampler.cpp
    │   │   │   ├── SWSamplerCache.h
    │   │   │   ├── SWShaderModel.cpp
    │   │   │   ├── SWShaderModel.h
    │   │   │   ├── SWSyncManager.cpp
    │   │   │   └── SWSyncObjects.h
    │   │   ├── ShaderLang
    │   │   │   ├── SWLang.h
    │   │   │   ├── SWLangArray.h
    │   │   │   ├── SWLangBarrier.h
    │   │   │   ├── SWLangBuffer.h
    │   │   │   ├── SWLangCommon.h
    │   │   │   ├── SWLangGLM.h
    │   │   │   ├── SWLangImage.cpp
    │   │   │   ├── SWLangImage.h
    │   │   │   ├── SWLangShared.h
    │   │   │   ├── SWLangTexture.cpp
    │   │   │   ├── SWLangTexture.h
    │   │   │   ├── SWLangTexture2D.h
    │   │   │   ├── SWShaderHelper.h
    │   │   │   ├── gen_Image.h
    │   │   │   └── gen_Texture.h
    │   │   ├── SoftRendererContext.cpp
    │   │   ├── SoftRendererObjectsConstructor.h
    │   │   ├── SoftRendererThread.cpp
    │   │   └── Windows
    │   │   │   ├── SwWinSurface.cpp
    │   │   │   └── SwWinSurface.h
    │   ├── VR
    │   │   ├── Emulator
    │   │   │   └── EmulatorVRThread.cpp
    │   │   ├── VRObjectsConstructor.cpp
    │   │   └── VRObjectsConstructor.h
    │   ├── Vulkan
    │   │   ├── 110
    │   │   │   ├── Vk1BaseModule.cpp
    │   │   │   ├── Vk1BaseModule.h
    │   │   │   ├── Vk1BaseObject.h
    │   │   │   ├── Vk1Buffer.cpp
    │   │   │   ├── Vk1CommandBuffer.cpp
    │   │   │   ├── Vk1CommandBuilder.cpp
    │   │   │   ├── Vk1CommandQueue.cpp
    │   │   │   ├── Vk1Device.cpp
    │   │   │   ├── Vk1Device.h
    │   │   │   ├── Vk1Enums.h
    │   │   │   ├── Vk1Framebuffer.cpp
    │   │   │   ├── Vk1Image.cpp
    │   │   │   ├── Vk1Library.h
    │   │   │   ├── Vk1ManagedMemory.cpp
    │   │   │   ├── Vk1MemoryManager.cpp
    │   │   │   ├── Vk1Messages.h
    │   │   │   ├── Vk1Pipeline.cpp
    │   │   │   ├── Vk1PipelineCache.cpp
    │   │   │   ├── Vk1PipelineCache.h
    │   │   │   ├── Vk1PipelineLayout.cpp
    │   │   │   ├── Vk1PipelineLayout.h
    │   │   │   ├── Vk1PipelineResourceTable.cpp
    │   │   │   ├── Vk1QueryPool.cpp
    │   │   │   ├── Vk1RenderPass.cpp
    │   │   │   ├── Vk1RenderPassCache.h
    │   │   │   ├── Vk1ResourceCache.h
    │   │   │   ├── Vk1Sampler.cpp
    │   │   │   ├── Vk1SamplerCache.h
    │   │   │   ├── Vk1SwapchainImage.h
    │   │   │   ├── Vk1SyncManager.cpp
    │   │   │   ├── vulkan1.cpp
    │   │   │   ├── vulkan1.h
    │   │   │   ├── vulkan1_platform.cpp
    │   │   │   ├── vulkan1_platform.h
    │   │   │   └── vulkan1_utils.h
    │   │   ├── Android
    │   │   │   ├── VkAndSurface.cpp
    │   │   │   └── VkAndSurface.h
    │   │   ├── Linux
    │   │   │   ├── VkLinuxSurface.cpp
    │   │   │   └── VkLinuxSurface.h
    │   │   ├── VulkanContext.cpp
    │   │   ├── VulkanObjectsConstructor.h
    │   │   ├── VulkanThread.cpp
    │   │   └── Windows
    │   │   │   ├── VkWinSurface.cpp
    │   │   │   └── VkWinSurface.h
    │   └── Windows
    │   │   ├── WinDisplay.cpp
    │   │   ├── WinDisplay.h
    │   │   ├── WinKeyInput.cpp
    │   │   ├── WinMessages.h
    │   │   ├── WinMouseInput.cpp
    │   │   ├── WinObjectsConstructor.h
    │   │   ├── WinPlatform.cpp
    │   │   └── WinWindow.cpp
    ├── Profilers
    │   ├── Engine.Profilers.h
    │   ├── Impl
    │   │   ├── FPSCounter.cpp
    │   │   ├── Main.cpp
    │   │   └── ProfilerObjectsConstructor.h
    │   └── Public
    │   │   ├── Common.h
    │   │   ├── GpuStatistic.h
    │   │   └── IDs.h
    ├── README.md
    ├── ResourcePacker
    │   ├── FilePacker
    │   │   ├── BinaryFilePacker.cpp
    │   │   ├── BinaryFilePacker.h
    │   │   ├── CppFileSystemPacker.cpp
    │   │   ├── CppFileSystemPacker.h
    │   │   └── IFileSystemPacker.h
    │   ├── Images
    │   │   ├── DevILConverter.cpp
    │   │   ├── ImageConverter.cpp
    │   │   └── ImageConverter.h
    │   ├── Main.cpp
    │   ├── Packer
    │   │   ├── Common.h
    │   │   ├── ResourcePacker.cpp
    │   │   ├── ResourcePacker.h
    │   │   └── ScriptHelper.cpp
    │   └── Pipelines
    │   │   ├── PipelineConverter.cpp
    │   │   ├── PipelineConverter.h
    │   │   ├── ScriptComputePipeline.cpp
    │   │   ├── ScriptComputePipeline.h
    │   │   ├── ScriptGraphicsPipeline.cpp
    │   │   ├── ScriptGraphicsPipeline.h
    │   │   ├── ScriptPipeline.cpp
    │   │   └── ScriptPipeline.h
    └── Scene
    │   ├── Camera
    │       ├── FreeCamera.cpp
    │       └── FreeVRCamera.cpp
    │   ├── Engine.Scene.h
    │   ├── Impl
    │       ├── BaseSceneModule.cpp
    │       ├── BaseSceneModule.h
    │       ├── Main.cpp
    │       ├── SceneMainThread.cpp
    │       ├── SceneManager.cpp
    │       └── SceneObjectConstructor.h
    │   ├── Logic
    │       └── SceneLogicMainThread.cpp
    │   ├── Physics
    │       └── ScenePhysicsMainThread.cpp
    │   ├── Public
    │       ├── Camera.h
    │       ├── Common.h
    │       ├── IDs.h
    │       ├── Scene.h
    │       └── Surface.h
    │   ├── Renderer
    │       └── SceneRendererMainThread.cpp
    │   └── Surface
    │       ├── OffscreenSurface.cpp
    │       ├── VRSurface.cpp
    │       ├── VideoRecorderSurface.cpp
    │       └── WindowSurface.cpp
├── EngineTests
    ├── Base
    │   ├── Common.h
    │   ├── Graphics
    │   │   ├── GApp.cpp
    │   │   ├── GApp.h
    │   │   └── Test.GWindow.cpp
    │   ├── Main.cpp
    │   ├── Pipelines
    │   │   ├── Default.ppln
    │   │   ├── Default2.ppln
    │   │   ├── all_pipelines.h
    │   │   ├── default.cpp
    │   │   ├── default2.cpp
    │   │   ├── resources.as
    │   │   └── shared_types.h
    │   └── Window
    │   │   └── Test.Window.cpp
    ├── Graphics
    │   ├── GApp.cpp
    │   ├── GApp.h
    │   ├── Main.cpp
    │   └── Pipelines
    │   │   ├── Default3.ppln
    │   │   ├── all_pipelines.h
    │   │   ├── default3.cpp
    │   │   ├── resources.as
    │   │   └── shared_types.h
    └── Platforms.GAPI
    │   ├── Common.h
    │   ├── Compiler
    │       ├── PApp.cpp
    │       ├── PApp.h
    │       ├── PApp_AtomicAdd.cpp
    │       ├── PApp_FindLSB.cpp
    │       ├── PApp_FindMSB.cpp
    │       ├── PApp_GlobalToLocal.cpp
    │       ├── PApp_Include.cpp
    │       ├── PApp_InlineAll.cpp
    │       ├── PApp_UnnamedBuffer.cpp
    │       ├── PApp_VecSwizzle.cpp
    │       ├── Pipelines
    │       │   ├── AtomicAdd.ppln
    │       │   ├── FindLSB.ppln
    │       │   ├── FindMSB.ppln
    │       │   ├── GlobalToLocal.ppln
    │       │   ├── Include.ppln
    │       │   ├── InlineAll.ppln
    │       │   ├── UnnamedBuffer.ppln
    │       │   ├── VecSwizzle.ppln
    │       │   ├── all_pipelines.h
    │       │   ├── atomicadd.cpp
    │       │   ├── findlsb.cpp
    │       │   ├── findmsb.cpp
    │       │   ├── globaltolocal.cpp
    │       │   ├── include.cpp
    │       │   ├── inlineall.cpp
    │       │   ├── shared_types.h
    │       │   ├── unnamedbuffer.cpp
    │       │   └── vecswizzle.cpp
    │       └── Test.PipelineCompiler.cpp
    │   ├── Compute
    │       ├── CApp.cpp
    │       ├── CApp.h
    │       ├── CApp_BufferAlign.cpp
    │       ├── CApp_BufferRange.cpp
    │       ├── CApp_ClearBuffer.cpp
    │       ├── CApp_ConvertFloatImage2D.cpp
    │       ├── CApp_CopyBuffer.cpp
    │       ├── CApp_CopyBufferToImage2D.cpp
    │       ├── CApp_CopyImage2D.cpp
    │       ├── CApp_CopyImage2DToBuffer.cpp
    │       ├── CApp_DynamicBuffer.cpp
    │       ├── CApp_ExplicitMemoryObjectSharing.cpp
    │       ├── CApp_Image2DBilinearFilter.cpp
    │       ├── CApp_Image2DNearestFilter.cpp
    │       ├── CApp_ShaderBarrier.cpp
    │       ├── CApp_UpdateBuffer.cpp
    │       ├── Pipelines
    │       │   ├── BufferAlign.ppln
    │       │   ├── CopyFloatImage2D.ppln
    │       │   ├── DynamicBuffer.ppln
    │       │   ├── Image2DBilinearFilter.ppln
    │       │   ├── Image2DNearestFilter.ppln
    │       │   ├── ShaderBarrier.ppln
    │       │   ├── all_pipelines.h
    │       │   ├── bufferalign.cpp
    │       │   ├── copyfloatimage2d.cpp
    │       │   ├── dynamicbuffer.cpp
    │       │   ├── image2dbilinearfilter.cpp
    │       │   ├── image2dnearestfilter.cpp
    │       │   ├── shaderbarrier.cpp
    │       │   └── shared_types.h
    │       └── Test.ComputeApi.cpp
    │   ├── Graphics
    │       ├── GApp.cpp
    │       ├── GApp.h
    │       ├── GApp_Texture2DBilinearFilter.cpp
    │       ├── GApp_Texture2DNearestFilter.cpp
    │       ├── Pipelines
    │       │   ├── Texture2DBilinearFilter.ppln
    │       │   ├── Texture2DNearestFilter.ppln
    │       │   ├── all_pipelines.h
    │       │   ├── shared_types.h
    │       │   ├── texture2dbilinearfilter.cpp
    │       │   └── texture2dnearestfilter.cpp
    │       └── Test.GraphicsApi.cpp
    │   ├── Main.cpp
    │   ├── MultiGPU
    │       └── Test.MultiGPU.cpp
    │   ├── Sharing
    │       ├── SApp.cpp
    │       ├── SApp.h
    │       ├── SApp_BufferSharing.cpp
    │       ├── SApp_ImageSharing.cpp
    │       └── Test.Sharing.cpp
    │   ├── Window
    │       ├── Test.Window.cpp
    │       └── Window1.h
    │   └── resources.as
├── External
    ├── README.md
    ├── cmake
    │   ├── AngelScript
    │   │   ├── CMakeLists.txt
    │   │   └── build.cmake
    │   ├── CMakeLists.txt
    │   ├── DevIL
    │   │   ├── build.cmake
    │   │   └── main.cpp
    │   ├── DirectX
    │   │   └── dx11.cmake
    │   ├── FreeImage
    │   │   └── build.cmake
    │   ├── SDL2
    │   │   └── build.cmake
    │   ├── download.cmake
    │   ├── glslang
    │   │   ├── build.cmake
    │   │   └── build_internal.cmake
    │   ├── lodepng
    │   │   └── build.cmake
    │   ├── lz4
    │   │   ├── CMakeLists.txt
    │   │   └── build.cmake
    │   ├── miniz
    │   │   ├── CMakeLists.txt
    │   │   └── build.cmake
    │   └── options.cmake
    ├── downloaded
    │   ├── AngelScript
    │   │   └── sdk
    │   │   │   └── angelscript
    │   │   │       └── projects
    │   │   │           └── cmake
    │   │   │               └── CMakeLists.txt
    │   ├── SDL2
    │   │   └── CMakeLists.txt
    │   └── glslang
    │   │   └── CMakeLists.txt
    ├── opencl
    │   ├── cl_platform.h
    │   ├── opencl11_core.h
    │   ├── opencl11_gl.h
    │   ├── opencl12_core.h
    │   ├── opencl12_gl.h
    │   ├── opencl20_core.h
    │   ├── opencl20_gl.h
    │   ├── opencl21_core.h
    │   ├── opencl21_gl.h
    │   ├── opencl22_core.h
    │   ├── opencl22_gl.h
    │   └── origin
    │   │   ├── opencl10
    │   │       └── CL
    │   │       │   ├── cl.h
    │   │       │   ├── cl_d3d10.h
    │   │       │   ├── cl_ext.h
    │   │       │   ├── cl_gl.h
    │   │       │   ├── cl_gl_ext.h
    │   │       │   ├── cl_platform.h
    │   │       │   └── opencl.h
    │   │   ├── opencl11
    │   │       └── CL
    │   │       │   ├── cl.h
    │   │       │   ├── cl_d3d10.h
    │   │       │   ├── cl_ext.h
    │   │       │   ├── cl_gl.h
    │   │       │   ├── cl_gl_ext.h
    │   │       │   ├── cl_platform.h
    │   │       │   └── opencl.h
    │   │   ├── opencl12
    │   │       └── CL
    │   │       │   ├── cl.h
    │   │       │   ├── cl_d3d10.h
    │   │       │   ├── cl_d3d11.h
    │   │       │   ├── cl_dx9_media_sharing.h
    │   │       │   ├── cl_dx9_media_sharing_intel.h
    │   │       │   ├── cl_egl.h
    │   │       │   ├── cl_ext.h
    │   │       │   ├── cl_ext_intel.h
    │   │       │   ├── cl_gl.h
    │   │       │   ├── cl_gl_ext.h
    │   │       │   ├── cl_platform.h
    │   │       │   ├── cl_va_api_media_sharing_intel.h
    │   │       │   └── opencl.h
    │   │   ├── opencl20
    │   │       └── CL
    │   │       │   ├── cl.h
    │   │       │   ├── cl_d3d10.h
    │   │       │   ├── cl_d3d11.h
    │   │       │   ├── cl_dx9_media_sharing.h
    │   │       │   ├── cl_dx9_media_sharing_intel.h
    │   │       │   ├── cl_egl.h
    │   │       │   ├── cl_ext.h
    │   │       │   ├── cl_ext_intel.h
    │   │       │   ├── cl_gl.h
    │   │       │   ├── cl_gl_ext.h
    │   │       │   ├── cl_platform.h
    │   │       │   ├── cl_va_api_media_sharing_intel.h
    │   │       │   └── opencl.h
    │   │   ├── opencl21
    │   │       └── CL
    │   │       │   ├── cl.h
    │   │       │   ├── cl_d3d10.h
    │   │       │   ├── cl_d3d11.h
    │   │       │   ├── cl_dx9_media_sharing.h
    │   │       │   ├── cl_dx9_media_sharing_intel.h
    │   │       │   ├── cl_egl.h
    │   │       │   ├── cl_ext.h
    │   │       │   ├── cl_ext_intel.h
    │   │       │   ├── cl_gl.h
    │   │       │   ├── cl_gl_ext.h
    │   │       │   ├── cl_platform.h
    │   │       │   ├── cl_va_api_media_sharing_intel.h
    │   │       │   └── opencl.h
    │   │   └── opencl22
    │   │       └── CL
    │   │           ├── cl.h
    │   │           ├── cl_d3d10.h
    │   │           ├── cl_d3d11.h
    │   │           ├── cl_dx9_media_sharing.h
    │   │           ├── cl_dx9_media_sharing_intel.h
    │   │           ├── cl_egl.h
    │   │           ├── cl_ext.h
    │   │           ├── cl_ext_intel.h
    │   │           ├── cl_gl.h
    │   │           ├── cl_gl_ext.h
    │   │           ├── cl_platform.h
    │   │           ├── cl_va_api_media_sharing_intel.h
    │   │           └── opencl.h
    ├── opengl
    │   ├── glxext.h
    │   ├── opengl44_core.h
    │   ├── opengl45_core.h
    │   ├── opengl46_core.h
    │   ├── origin
    │   │   ├── glcorearb44.h
    │   │   ├── glcorearb45.h
    │   │   └── glcorearb46.h
    │   └── wglext.h
    ├── opengles
    │   ├── opengles32.h
    │   └── origin
    │   │   ├── gl32.h
    │   │   └── gl3platform.h
    └── vulkan
    │   ├── gen_vulkan_1.h
    │   ├── gen_vulkan_1_and.h
    │   ├── gen_vulkan_1_mir.h
    │   ├── gen_vulkan_1_wayland.h
    │   ├── gen_vulkan_1_win.h
    │   ├── gen_vulkan_1_xcb.h
    │   ├── gen_vulkan_1_xlib.h
    │   ├── origin
    │       ├── vk_icd.h
    │       ├── vk_layer.h
    │       ├── vk_platform.h
    │       ├── vk_sdk_platform.h
    │       ├── vulkan.h
    │       ├── vulkan_android.h
    │       ├── vulkan_core.h
    │       ├── vulkan_ios.h
    │       ├── vulkan_macos.h
    │       ├── vulkan_mir.h
    │       ├── vulkan_vi.h
    │       ├── vulkan_wayland.h
    │       ├── vulkan_win32.h
    │       ├── vulkan_xcb.h
    │       ├── vulkan_xlib.h
    │       └── vulkan_xlib_xrandr.h
    │   └── vulkan_api_1.h
├── LICENSE
├── Projects
    └── ShaderEditor
    │   ├── CMakeLists.txt
    │   ├── Common.h
    │   ├── Pipelines
    │       ├── DrawTexturedQuad.ppln
    │       ├── Experimental.ppln
    │       ├── Glowballs.ppln
    │       ├── ShaderToy.tmpl
    │       ├── ShaderToyComp.tmpl
    │       ├── SirenianDawn1.ppln
    │       ├── SirenianDawn2.ppln
    │       ├── Skyline.ppln
    │       ├── VoronnoiRecursion.ppln
    │       ├── all_pipelines.h
    │       ├── drawtexturedquad.cpp
    │       ├── experimental.cpp
    │       ├── glowballs.cpp
    │       ├── shared_types.h
    │       ├── sireniandawn1.cpp
    │       ├── sireniandawn2.cpp
    │       ├── skyline.cpp
    │       └── voronnoirecursion.cpp
    │   ├── README.md
    │   ├── Renderer.cpp
    │   ├── Renderer.h
    │   ├── ShaderEditorApp.cpp
    │   ├── ShaderEditorApp.h
    │   ├── ShaderEditorApp_Samples.cpp
    │   ├── images
    │       ├── greynoise.cpp
    │       ├── vfs_images_main.cpp
    │       └── vfs_images_main.h
    │   ├── res
    │       ├── greynoise.png
    │       └── old
    │       │   ├── img.png
    │       │   └── img1.png
    │   └── resources.as
├── README.md
└── Utils
    ├── CMake
        ├── Builder
        │   ├── CMakeBuilder.cpp
        │   ├── CMakeBuilder.h
        │   ├── CMakeBuilder_Compiler.cpp
        │   ├── CMakeBuilder_ExternalProjects.cpp
        │   ├── CMakeBuilder_Project.cpp
        │   ├── ClangConstants.h
        │   ├── GccConstants.h
        │   └── MSVisualStudioConstants.h
        └── Proj
        │   ├── GenCompilers.cpp
        │   ├── GenCore.cpp
        │   ├── GenEngine.cpp
        │   ├── GenShaderEditor.cpp
        │   ├── GenUtils.cpp
        │   ├── Main.cpp
        │   └── PipelineBuilding.h
    └── CMakeLists.txt


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.obj
 2 | *.tlog
 3 | *.lib
 4 | *.ilk
 5 | *.log
 6 | *.pdb
 7 | *.exe
 8 | *.db
 9 | *.suo
10 | *.html
11 | *.db-wal
12 | *.db-shm
13 | *.opendb
14 | *.ipch
15 | *.idb
16 | *.exp
17 | *.tmp
18 | *.dll
19 | *.iobj
20 | *.ipdb
21 | /build
22 | /Tests/PipelineCompiler/out
23 | /External/FreeImage
24 | /External/glm
25 | /External/OculusSDK


--------------------------------------------------------------------------------
/Android/.gitignore:
--------------------------------------------------------------------------------
 1 | *.idea
 2 | *.iml
 3 | .gradle
 4 | /local.properties
 5 | /.idea/workspace.xml
 6 | /.idea/libraries
 7 | .DS_Store
 8 | /build
 9 | /captures
10 | .externalNativeBuild
11 | 


--------------------------------------------------------------------------------
/Android/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | 


--------------------------------------------------------------------------------
/Android/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # By default, the flags in this file are appended to flags specified
 3 | # in /Users/user/Library/Android/sdk/tools/proguard/proguard-android.txt
 4 | # You can edit the include path and order by changing the proguardFiles
 5 | # directive in build.gradle.
 6 | #
 7 | # For more details, see
 8 | #   http://developer.android.com/guide/developing/tools/proguard.html
 9 | 
10 | # Add any project specific keep options here:
11 | 
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | #   public *;
17 | #}
18 | 


--------------------------------------------------------------------------------
/Android/app/src/main/java/mgf/android/GXActivity.java:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | */
 4 | 
 5 | package mgf.android;
 6 | 
 7 | import android.app.NativeActivity;
 8 | import android.content.Intent;
 9 | import android.os.Bundle;
10 | import android.util.Log;
11 | import android.view.KeyEvent;
12 | 
13 | public class GXActivity extends NativeActivity {
14 | 
15 |     static {
16 |         System.loadLibrary( "ModularGraphicsFramework" );
17 |     }
18 | 
19 | 
20 | 	public GXActivity() {
21 | 		super();
22 | 	}
23 | 
24 | 	@Override
25 | 	public void onCreate(Bundle savedInstanceState) {
26 | 		super.onCreate(savedInstanceState);
27 | 	}
28 | 
29 | 	@Override
30 | 	public void onStart() {
31 | 		super.onStart();
32 | 	}
33 | 
34 | 	@Override
35 | 	public void onDestroy() {
36 | 		super.onDestroy();
37 | 	}
38 | 
39 | 	@Override
40 | 	public boolean dispatchKeyEvent(KeyEvent event) {
41 | 
42 | 		return super.dispatchKeyEvent(event);
43 | 	}
44 | 
45 | 	@Override
46 | 	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
47 | 		super.onActivityResult(requestCode, resultCode, data);
48 | 	}
49 | 
50 | 	@Override
51 | 	public void onStop() {
52 | 		super.onStop();
53 | 	}
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/Android/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Android/app/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/Android/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Android/app/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/Android/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Android/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/Android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/Android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/Android/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/Android/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">ModularGraphicsFramework Android Sample</string>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/Android/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/Android/build.gradle:
--------------------------------------------------------------------------------
 1 | // Top-level build file where you can add configuration options common to all sub-projects/modules.
 2 | 
 3 | buildscript {
 4 |     repositories {
 5 |         jcenter()
 6 |         google()
 7 |     }
 8 |     dependencies {
 9 |         classpath 'com.android.tools.build:gradle:3.1.0'
10 | 
11 |         // NOTE: Do not place your application dependencies here; they belong
12 |         // in the individual module build.gradle files
13 |     }
14 | }
15 | 
16 | allprojects {
17 |     repositories {
18 |         jcenter()
19 |         flatDir {
20 |             dirs 'libs'
21 |         }
22 |         google()
23 |     }
24 | }
25 | 
26 | task clean(type: Delete) {
27 |     delete rootProject.buildDir
28 | }
29 | 


--------------------------------------------------------------------------------
/Android/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | 
 3 | # IDE (e.g. Android Studio) users:
 4 | # Gradle settings configured through the IDE *will override*
 5 | # any settings specified in this file.
 6 | 
 7 | # For more details on how to configure your build environment visit
 8 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 9 | 
10 | # Specifies the JVM arguments used for the daemon process.
11 | # The setting is particularly useful for tweaking memory settings.
12 | org.gradle.jvmargs=-Xmx1536m
13 | 
14 | # When configured, Gradle will run in incubating parallel mode.
15 | # This option should only be used with decoupled projects. More details, visit
16 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
17 | # org.gradle.parallel=true
18 | 


--------------------------------------------------------------------------------
/Android/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app'


--------------------------------------------------------------------------------
/Core/Config/Engine.Version.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | namespace Engine
 6 | {
 7 | 	static const char	ENGINE_NAME[]		= "ModularGraphicsFramework";
 8 | 	static const char	ENGINE_BUILD_DATE[]	= __DATE__ " " __TIME__;
 9 | 	static const int	_ENGINE_VERSION_MAJ	= 0;
10 | 	static const int	_ENGINE_VERSION_MIN	= 300;
11 | 	static const int	ENGINE_VERSION		= _ENGINE_VERSION_MAJ * 1000 + _ENGINE_VERSION_MIN;
12 | 
13 | 
14 | }	// Engine


--------------------------------------------------------------------------------
/Core/Config/Main.cpp:
--------------------------------------------------------------------------------
1 | // empty file to create lib


--------------------------------------------------------------------------------
/Core/Physics/Algorithms/AcceleratedMotion.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Physics/Dimensions/PhysicsValueMath.h"
 6 | #include "Core/Physics/CompileTime/PhysTypeInfo.h"
 7 | #include "Core/Physics/CompileTime/GenType.h"
 8 | 
 9 | namespace GXPhysics
10 | {
11 | 
12 | /*
13 | =================================================
14 | 	UniformlyAcceleratedMotion
15 | =================================================
16 | */
17 | 	template <typename Pos, typename Vel, typename Accel, typename Time>
18 | 	inline void UniformlyAcceleratedMotion (INOUT Pos &pos, INOUT Vel &vel, const Accel accel, const Time dt)
19 | 	{
20 | 		STATIC_ASSERT( IsTimeUnits<Time> and IsAccelerationUnits<Accel> and IsVelocityUnits<Vel> and IsDistanceUnits<Pos> );
21 | 		
22 | 		using T = PXGenType< Pos, Vel, Accel, Time >;
23 | 
24 | 		pos += vel * dt * T(0.5);
25 | 		vel += accel * dt;
26 | 		pos += vel * dt * T(0.5);
27 | 	}
28 | 
29 | }	// GXPhysics


--------------------------------------------------------------------------------
/Core/Physics/Common/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #define GX_PHYSICS_DIMENSIONS_ENABLED
 6 | 
 7 | #include "Core/STL/CompileTime/StaticFractional.h"
 8 | #include "Core/STL/CompileTime/StaticFloat.h"
 9 | #include "Core/STL/CompileTime/StaticInteger.h"
10 | #include "Core/STL/CompileTime/TypeList.h"
11 | #include "Core/STL/Math/Mathematics.h"
12 | #include "Core/STL/Math/Vec.h"
13 | #include "Core/STL/Math/BinaryMath.h"
14 | #include "Core/STL/Math/Interpolations.h"
15 | 
16 | namespace GXPhysics
17 | {
18 | 	using namespace GX_STL;
19 | 	using namespace GX_STL::GXTypes;
20 | 	using namespace GX_STL::GXMath;
21 | 
22 | 
23 | #	define PX_AUTO( _type_ )	auto
24 | 
25 | }	// GXPhysics
26 | 


--------------------------------------------------------------------------------
/Core/Physics/Common/Main.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
2 | 


--------------------------------------------------------------------------------
/Core/Physics/CompileTime/GenType.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/CompileTime/TypeListHelpers.h"
 6 | #include "Core/Physics/Dimensions/PhysicsValue.h"
 7 | 
 8 | namespace GXPhysics
 9 | {
10 | 
11 | 	namespace _phys_hidden_
12 | 	{
13 | 		template <usize, typename Type, typename PrevFuncResult, typename>
14 | 		struct _TypeList_GetInnerTypeFromPhysicsValue
15 | 		{
16 | 			using result = CompileTime::TypeList< typename Type::Value_t, PrevFuncResult >;
17 | 		};
18 | 		
19 | 		template <typename Typelist>
20 | 		using InnerTypes_t = typename Typelist::template ForEach< _TypeList_GetInnerTypeFromPhysicsValue, CompileTime::TypeListEnd >;
21 | 		
22 | 		template <typename Typelist>
23 | 		using GenTypeFromInner_t = typename InnerTypes_t< Typelist >::template ForEach< CompileTime::_ctime_hidden_::GenType_Choose<false>::Func, float >;
24 | 
25 | 	}	// _phys_hidden_
26 | 
27 | 
28 | 	template <typename ...Types>
29 | 	using PXGenType = typename _phys_hidden_::GenTypeFromInner_t< CompileTime::TypeListFrom< Types... > >;
30 | 
31 | 
32 | }	// GXPhysics
33 | 


--------------------------------------------------------------------------------
/Core/Physics/CompileTime/PhysTypeInfo.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Physics/Dimensions/PhysicsValueMath.h"
 6 | 
 7 | namespace GXPhysics
 8 | {
 9 | 
10 | 	// Is***Units //
11 | 	template <typename T>
12 | 	static constexpr bool	IsMassUnits = T::Dimensions_t::template Equal< typename DefaultPhysicsDimensions::Kilogram >::value;
13 | 
14 | 	template <typename T>
15 | 	static constexpr bool	IsDistanceUnits = T::Dimensions_t::template Equal< typename DefaultPhysicsDimensions::Meter >::value;
16 | 
17 | 	template <typename T>
18 | 	static constexpr bool	IsDensityUnits = T::Dimensions_t::template Equal< DefaultPhysicsDimensions::KilogramPerCubicMeter >::value;
19 | 
20 | 	template <typename T>
21 | 	static constexpr bool	IsVelocityUnits = T::Dimensions_t::template Equal< DefaultPhysicsDimensions::MeterPerSecond >::value;
22 | 	
23 | 	template <typename T>
24 | 	static constexpr bool	IsAccelerationUnits = T::Dimensions_t::template Equal< DefaultPhysicsDimensions::MeterPerSquareSecond >::value;
25 | 	
26 | 	template <typename T>
27 | 	static constexpr bool	IsTimeUnits = T::Dimensions_t::template Equal< DefaultPhysicsDimensions::Second >::value;
28 | 
29 | 	template <typename T1, typename T2>
30 | 	static constexpr bool	IsSameDimensions = T1::Dimensions_t::template Equal< T2::Dimensions_t >::value;
31 | 
32 | 
33 | }	// GXPhysics
34 | 


--------------------------------------------------------------------------------
/Core/Physics/Core.Physics.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	This is not a physics engine, just a simple types, shapes and algorithms.
 4 | */
 5 | 
 6 | // Dimensions
 7 | #include "Core/Physics/Dimensions/PhysicsValue.h"
 8 | #include "Core/Physics/Dimensions/PhysicsValueMath.h"
 9 | #include "Core/Physics/Dimensions/PhysicsValueVec.h"
10 | 
11 | // Constants
12 | 
13 | // Algorithms
14 | #include "Core/Physics/Algorithms/AcceleratedMotion.h"
15 | #include "Core/Physics/Algorithms/Astrophysics.h"
16 | #include "Core/Physics/Algorithms/Astrophysics_Orbit.h"
17 | 
18 | // Shapes
19 | 


--------------------------------------------------------------------------------
/Core/Physics/Dimensions/AstrophysicsConstants.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | namespace GXPhysics
 6 | {
 7 | namespace Astrophysics
 8 | {
 9 | 
10 | 
11 | }	// Astrophysics
12 | }	// GXPhysics
13 | 


--------------------------------------------------------------------------------
/Core/Physics/Dimensions/PhysicsConstants.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 


--------------------------------------------------------------------------------
/Core/Physics/Dimensions/PhysicsValueMath.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Physics/Dimensions/PhysicsValueVec.h"
 6 | 
 7 | namespace GXPhysics
 8 | {
 9 | 
10 | 	template <typename AValueType, typename ADimensions, typename AValueScale,
11 | 			  typename BValueType, typename BDimensions, typename BValueScale
12 | 			 >
13 | 	ND_ forceinline auto  MiddleValue (const PhysicsValue<AValueType, ADimensions, AValueScale>& a,
14 | 										const PhysicsValue<BValueType, BDimensions, BValueScale>& b)
15 | 	{
16 | 		return decltype(a+b)(GXMath::MiddleValue( a.ref(), b.ref() ));
17 | 	}
18 | 
19 | }	// GXPhysics
20 | 


--------------------------------------------------------------------------------
/Core/README.md:
--------------------------------------------------------------------------------
1 | # Core library
2 | * STL - base types, math, collections, algorithms.
3 | * Script - wrapper for AngelScript.
4 | * Physics - math for physics.


--------------------------------------------------------------------------------
/Core/STL/Algorithms/Crypt/SimpleCrypt.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Containers/ArrayRef.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 
12 | 	//
13 | 	// Simple Crypt Algorithm (XOR)
14 | 	//
15 | 
16 | 	struct SimpleCryptAlgorithm
17 | 	{
18 | 		// source to encrypted
19 | 		template <typename T, typename B>
20 | 		static bool Encrypt (INOUT ArrayRef<T> data, ArrayCRef<B> password)
21 | 		{
22 | 			FOR( i, data )
23 | 			{
24 | 				FOR( j, password )
25 | 				{
26 | 					data[i] ^= ( password[j] + i*j );
27 | 				}
28 | 			}
29 | 			return true;
30 | 		}
31 | 
32 | 		// encrypted to source
33 | 		template <typename T, typename B>
34 | 		static bool Decrypt (INOUT ArrayRef<T> data, ArrayCRef<B> password)
35 | 		{
36 | 			return Encrypt( data, password );
37 | 		}
38 | 	};
39 | 
40 | 
41 | 
42 | 	//
43 | 	// Crypt
44 | 	//
45 | 	/*
46 | 	template <typename T, typename CryptAlgorithmType = SimpleCryptAlgorithm >
47 | 	struct Crypt
48 | 	{
49 | 	// types
50 | 	public:
51 | 		typedef CryptAlgorithmType	Algorithm;
52 | 
53 | 
54 | 	// methods
55 | 	public:
56 | 	};
57 | 	*/
58 | 
59 | 
60 | }	// GXTypes
61 | }	// GX_STL
62 | 


--------------------------------------------------------------------------------
/Core/STL/Algorithms/Swap.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 	
12 | /*
13 | =================================================
14 | 	SwapValues
15 | =================================================
16 | */
17 | 	template <typename T>
18 | 	forceinline void SwapValues (INOUT T &a, INOUT T &b)
19 | 	{
20 | 	#if 0
21 | 		T c(a);
22 | 		a = b;
23 | 		b = c;
24 | 	#elif 1
25 | 		T c	= RVREF( a );
26 | 		a	= RVREF( b );
27 | 		b	= RVREF( c );
28 | 	#else
29 | 		T c{ RVREF(a) };
30 | 		PlacementDelete( a );	UnsafeMem::PlacementNew<T>( AddressOf(a), RVREF(b) );
31 | 		PlacementDelete( b );	UnsafeMem::PlacementNew<T>( AddressOf(b), RVREF(c) );
32 | 	#endif
33 | 	}
34 | 	
35 | /*
36 | =================================================
37 | 	SwapValues
38 | =================================================
39 | */
40 | 	template <typename C, typename T>
41 | 	forceinline void SwapMembers (C *a, C *b, T C:: *member)
42 | 	{
43 | 		SwapValues( a->*member, b->*member );
44 | 	}
45 | 
46 | 	template <typename C, typename T>
47 | 	forceinline void SwapMembers (C &a, C &b, T C:: *member)
48 | 	{
49 | 		SwapValues( a.*member, b.*member );
50 | 	}
51 | 
52 | 
53 | }	// GXTypes
54 | }	// GX_STL
55 | 


--------------------------------------------------------------------------------
/Core/STL/Common/UMax.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 
12 | 	namespace _types_hidden_
13 | 	{
14 | 		struct _UMax
15 | 		{
16 | 			template <typename T>
17 | 			constexpr operator T () const
18 | 			{
19 | 				STATIC_ASSERT( ~T(0) > T(0) );
20 | 				return T(~T(0));
21 | 			}
22 | 			
23 | 			template <typename T>
24 | 			friend constexpr bool operator == (const T& left, const _UMax &right)
25 | 			{
26 | 				return T(right) == left;
27 | 			}
28 | 			
29 | 			template <typename T>
30 | 			friend constexpr bool operator != (const T& left, const _UMax &right)
31 | 			{
32 | 				return T(right) != left;
33 | 			}
34 | 		};
35 | 	}
36 | 
37 | 	static constexpr _types_hidden_::_UMax	UMax{};
38 | 
39 | }	// GXTypes
40 | }	// GX_STL
41 | 


--------------------------------------------------------------------------------
/Core/STL/CompileTime/CompileTimeChecks.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | 
 6 | namespace GX_STL
 7 | {
 8 | namespace GXTypes
 9 | {
10 | 
11 | 	STATIC_ASSERT( sizeof(char) == 1 );
12 | 	STATIC_ASSERT( sizeof(bool) == sizeof(char) );
13 | 	STATIC_ASSERT( sizeof(byte) == sizeof(char) );
14 | 	STATIC_ASSERT( sizeof(ubyte) == sizeof(char) );
15 | 	
16 | 	STATIC_ASSERT( sizeof(short) == sizeof(byte)*2 );
17 | 	STATIC_ASSERT( sizeof(ushort) == sizeof(ubyte)*2 );
18 | 	
19 | 	STATIC_ASSERT( sizeof(int) == sizeof(short)*2 );
20 | 	STATIC_ASSERT( sizeof(uint) == sizeof(ushort)*2 );
21 | 	
22 | 	STATIC_ASSERT( sizeof(ilong) == sizeof(int)*2 );
23 | 	STATIC_ASSERT( sizeof(ulong) == sizeof(uint)*2 );
24 | 
25 | 	STATIC_ASSERT( sizeof(usize) == sizeof(void *) );
26 | 	STATIC_ASSERT( sizeof(isize) == sizeof(void *) );
27 | 
28 | 	STATIC_ASSERT( sizeof(float)*2 == sizeof(double) );
29 | 	STATIC_ASSERT( sizeof(long double) >= sizeof(double) );
30 | 
31 | }	// GXTypes
32 | }	// GX_STL
33 | 


--------------------------------------------------------------------------------
/Core/STL/CompileTime/CompileTimeTypes.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | #include "Core/STL/Common/UMax.h"
 7 | 
 8 | namespace GX_STL
 9 | {
10 | namespace CompileTime
11 | {
12 | 	using wchar		= GXTypes::wchar;
13 | 	using byte		= GXTypes::byte;
14 | 	using ubyte		= GXTypes::ubyte;
15 | 	using ushort	= GXTypes::ushort;
16 | 	using uint		= GXTypes::uint;
17 | 	using usize		= GXTypes::usize;
18 | 	using isize		= GXTypes::isize;
19 | 	using ilong		= GXTypes::ilong;
20 | 	using ulong		= GXTypes::ulong;
21 | 
22 | 	static constexpr auto UMax = GXTypes::UMax;
23 | 
24 | }	// CompileTime
25 | }	// GX_STL
26 | 


--------------------------------------------------------------------------------
/Core/STL/CompileTime/DeferredTemplates.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/CompileTime/TemplateUtils.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace CompileTime
10 | {
11 | 
12 | 	//
13 | 	// Deferred Template Type
14 | 	//
15 | 
16 | 	/*
17 | 		example:
18 | 
19 | 			template <typename T> struct Templ {};
20 | 
21 | 			// switch type without template instantiation
22 | 			using D = SwitchType< condition, DeferredTemplate< Templ, T1 >, DeferredTemplate< Templ, T2 > >;
23 | 
24 | 			// instantiate only 1 template
25 | 			using T = D::type;
26 | 	*/
27 | 
28 | 	template <template <typename ...> class Templ, typename ...Types>
29 | 	struct DeferredTemplate
30 | 	{
31 | 		using type	= Templ< Types... >;
32 | 	};
33 | 
34 | 
35 | 	template <typename Left, typename Right>
36 | 	struct DeferredAnd
37 | 	{
38 | 		static const bool	value = Left::type::value and Right::type::value;
39 | 	};
40 | 
41 | 
42 | }	// CompileTime
43 | }	// GX_STL
44 | 


--------------------------------------------------------------------------------
/Core/STL/Compression/Compression.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Containers/ArrayRef.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXCompression
10 | {
11 | 	using namespace GX_STL::GXTypes;
12 | 
13 | 
14 | 
15 | 	//
16 | 	// Compressor interface
17 | 	//
18 | 
19 | 	class ICompressor
20 | 	{
21 | 	public:
22 | 		virtual ~ICompressor () {}
23 | 		virtual BytesU GetPrefferedSize (BytesU uncompressedSize) const = 0;
24 | 		virtual bool   Compress (BinArrayCRef src, INOUT BinArrayRef &dst) = 0;
25 | 	};
26 | 
27 | 
28 | 
29 | 	//
30 | 	// Stream Compressor interface
31 | 	//
32 | 
33 | 	class IStreamCompressor
34 | 	{
35 | 	};
36 | 
37 | 
38 | 
39 | 	//
40 | 	// Decompressor interface
41 | 	//
42 | 
43 | 	class IDecompressor
44 | 	{
45 | 	public:
46 | 		virtual ~IDecompressor () {}
47 | 		virtual BytesU GetPrefferedSize (BytesU compressedSize) const = 0;
48 | 		virtual bool   Decompress (BinArrayCRef src, INOUT BinArrayRef &dst) = 0;
49 | 	};
50 | 
51 | 
52 | 
53 | 	//
54 | 	// Stream Decompressor interface
55 | 	//
56 | 
57 | 	class IStreamDecompressor
58 | 	{
59 | 	};
60 | 
61 | 	
62 | }	// GXCompression
63 | }	// GX_STL
64 | 


--------------------------------------------------------------------------------
/Core/STL/Containers/Adaptors.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Containers/AppendableAdaptor.h"
 6 | #include "Core/STL/Containers/ErasableAdaptor.h"
 7 | // TODO: indexable, searchable, ...
 8 | 
 9 | #include "Core/STL/Containers/Array.h"
10 | #include "Core/STL/Containers/Queue.h"
11 | #include "Core/STL/Containers/CircularQueue.h"
12 | #include "Core/STL/Containers/StaticArray.h"
13 | #include "Core/STL/Containers/Stack.h"
14 | #include "Core/STL/Containers/IndexedArray.h"
15 | #include "Core/STL/Containers/Map.h"
16 | #include "Core/STL/Containers/Set.h"
17 | #include "Core/STL/Containers/HashMap.h"
18 | #include "Core/STL/Containers/HashSet.h"
19 | #include "Core/STL/Containers/UniBuffer.h"
20 | 
21 | namespace GX_STL
22 | {
23 | namespace GXTypes
24 | {
25 | 
26 | 	namespace ContainerAdaptors
27 | 	{
28 | 	}	// ContainerAdaptors
29 | 
30 | 
31 | 	template <typename T>
32 | 	using AppendableAdaptor		= ContainerAdaptors::Appendable<T>;
33 | 
34 | }	// GXTypes
35 | }	// GX_STL
36 | 


--------------------------------------------------------------------------------
/Core/STL/DataBase/Utf8StringUtils.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Containers/String.h"
 6 | 
 7 | #ifdef GX_SQLITE_DATABASE_ENABLED
 8 | 
 9 | namespace GX_STL
10 | {
11 | namespace GXDataBase
12 | {
13 | 
14 | 	//
15 | 	// UTF-8 String Utils
16 | 	//
17 | 
18 | 	struct Utf8StringUtils
19 | 	{
20 | 		static void EncodeToWindows1251 (StringCRef src, OUT String &dst);
21 | 
22 | 		static usize Length (const char *s)
23 | 		{
24 | 			usize len = 0;
25 | 			while (*s)
26 | 			{
27 | 				len += ( (*s++) & 0xc0 ) != 0x80;
28 | 			}
29 | 			return len;
30 | 		}
31 | 	};
32 | 
33 | 
34 | }	// GXDataBase
35 | }	// GX_STL
36 | 
37 | #endif	// GX_SQLITE_DATABASE_ENABLED
38 | 


--------------------------------------------------------------------------------
/Core/STL/Defines/CtorHelpers.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | 
 6 | // Default copy constructors and default assign operators //
 7 | #define GX_DEFCOPYCTOR_ASSIGN( _type_ ) \
 8 | 	_type_ (const _type_ &) = default; \
 9 | 	_type_ (_type_ &&) = default;\
10 | 	\
11 | 	_type_& operator = (const _type_ &) = default; \
12 | 	_type_& operator = (_type_ &&) = default;
13 | 
14 | 
15 | 
16 | // Default copy constructor only //
17 | #define GX_DEFCOPYCTOR_ONLY( _type_ ) \
18 | 	_type_ () = delete; \
19 | 	\
20 | 	_type_ (const _type_ &) = default; \
21 | 	_type_ (_type_ &&) = default;\
22 | 	\
23 | 	_type_& operator = (const _type_ &) = delete; \
24 | 	_type_& operator = (_type_ &&) = delete;
25 | 


--------------------------------------------------------------------------------
/Core/STL/Defines/MemberDetector.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | 		
 6 | // from https://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
 7 | #define GX_CREATE_MEMBER_DETECTOR( _X_ )													\
 8 | 	template<typename T> class Detect_##_X_ {												\
 9 | 		struct Fallback { int _X_; };														\
10 | 		struct Derived : T, Fallback { };													\
11 | 																							\
12 | 		template<typename U, U> struct Check;												\
13 | 																							\
14 | 		typedef char ArrayOfOne[1];															\
15 | 		typedef char ArrayOfTwo[2];															\
16 | 																							\
17 | 		template<typename U> static ArrayOfOne & func(Check<int Fallback::*, &U::_X_> *);	\
18 | 		template<typename U> static ArrayOfTwo & func(...);									\
19 | 		public:																				\
20 | 		typedef Detect_##_X_ type;															\
21 | 		enum { value = sizeof(func<Derived>(0)) == 2 };										\
22 | 	}
23 | 
24 | 


--------------------------------------------------------------------------------
/Core/STL/Math/2D/MathTypes2D.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Math/MathTypes.h"
 6 | #include "Core/STL/Math/Vec.h"
 7 | #include "Core/STL/Math/Mathematics.h"
 8 | #include "Core/STL/Dimensions/RadiansAndDegrees.h"
 9 | 
10 | namespace GX_STL
11 | {
12 | namespace GXMath
13 | {
14 | 	
15 | 	// Rectangle
16 | 	template <typename T, ulong UID = 0> struct Rectangle;
17 | 
18 | 	typedef Rectangle< float   >	RectF;
19 | 	typedef Rectangle< double  >	RectD;
20 | 	typedef Rectangle< int     >	RectI;
21 | 	typedef Rectangle< uint    >	RectU;
22 | 	typedef Rectangle< ilong   >	RectL;
23 | 	typedef Rectangle< real    >	Rect;
24 | 
25 | 
26 | 	// Line 2D
27 | 	template <typename T, ulong UID = 0> struct Line2;
28 | 
29 | 	//typedef Line2< half   >		Line2H;
30 | 	typedef Line2< float  >			Line2F;
31 | 	typedef Line2< double >			Line2D;
32 | 	typedef Line2< real   >			Line2R;
33 | 
34 | 	
35 | 	// Circle
36 | 	template <typename T, ulong UID = 0> struct Circle;
37 | 
38 | 	//typedef Circle< half   >		CircleH;
39 | 	typedef Circle< float  >		CircleF;
40 | 	typedef Circle< double >		CircleD;
41 | 	typedef Circle< real   >		CircleR;
42 | 
43 | 
44 | }	// GXMath
45 | }	// GX_STL
46 | 


--------------------------------------------------------------------------------
/Core/STL/Math/3D/MathTypes3D.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Math/MathTypes.h"
 6 | #include "Core/STL/Math/2D/MathTypes2D.h"
 7 | #include "Core/STL/Dimensions/RadiansAndDegrees.h"
 8 | 
 9 | namespace GX_STL
10 | {
11 | namespace GXMath
12 | {
13 | 
14 | }	// GXMath
15 | }	// GX_STL
16 | 


--------------------------------------------------------------------------------
/Core/STL/Math/MathConstants.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXMath
10 | {
11 | 
12 | 	//
13 | 	// Constants
14 | 	//
15 | 
16 | 	template <typename T>
17 | 	static constexpr T Pi = T( 3.14159265358979323846 );
18 | 
19 | 
20 | 	template <typename T>
21 | 	static constexpr T EulerNumber = T( 2.71828182845904523536 );
22 | 
23 | 	
24 | 	template <typename T>
25 | 	static constexpr T ReciporalPi = T( 0.3183098861837906715377 );
26 | 
27 | 
28 | }	// GXMath
29 | }	// GX_STL
30 | 


--------------------------------------------------------------------------------
/Core/STL/Math/Rand/RandEngine.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Math/Mathematics.h"
 6 | #include "Core/STL/OS/OSLowLevel.h"
 7 | 
 8 | namespace GX_STL
 9 | {
10 | namespace GXMath
11 | {
12 | 
13 | 	
14 | 	//
15 | 	// Default C Random Engne
16 | 	//
17 | 	
18 | 	struct DefaultRandomEngine
19 | 	{
20 | 		ND_ uint	operator () ()	const	{ return uint(rand()); }
21 | 		ND_ uint	Max()			const	{ return RAND_MAX; }
22 | 	};
23 | 
24 | 
25 | 
26 | 	//
27 | 	// Platfomr Random Engine
28 | 	//
29 | 
30 | 	struct PlatformRandomEngine
31 | 	{
32 | 	// variables
33 | 	private:
34 | 		OS::PlatformRandomDevice	_device;
35 | 
36 | 	// methods
37 | 	public:
38 | 		PlatformRandomEngine () : _device( StringCRef() )
39 | 		{}
40 | 		
41 | 		ND_ uint	operator () ()	const	{ uint result;  _device.Generate( result );  return result; }
42 | 		ND_ uint	Max()			const	{ return MaxValue< uint >(); }
43 | 	};
44 | 
45 | 
46 | 	/*
47 | #ifdef PLATFORM_WINDOWS
48 | 	template <uint MAX = 0xffff>
49 | 	struct TRandomEngineTicks
50 | 	{
51 | 		ND_ uint operator () ()	const	{ return ::GetTickCount() & MAX; }
52 | 		ND_ uint Max()			const	{ return MAX; }
53 | 	};
54 | #endif
55 | 	*/
56 | 
57 | 
58 | }	// GXMath
59 | }	// GX_STL
60 | 


--------------------------------------------------------------------------------
/Core/STL/Memory/MemoryViewer.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 	
12 | 	//
13 | 	// Memory Viewer
14 | 	//
15 | 
16 | 	template <typename T, usize I = 400>
17 | 	struct TMemoryViewer
18 | 	{
19 | 		// types
20 | 		typedef T					(*p_static_array_t)[I];
21 | 		typedef TMemoryViewer<T,I>	Self;
22 | 
23 | 		// value
24 | 		p_static_array_t	ptr;
25 | 
26 | 		// check
27 | 		STATIC_ASSERT( sizeof(T*) == sizeof(p_static_array_t), "size mismatch" );
28 | 	};
29 | 
30 | 
31 | }	// GXTypes
32 | }	// GX_STL
33 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Android/OSAndroid.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_ANDROID
 8 | 
 9 | #include "Core/STL/OS/Posix/OSPosix.h"
10 | 
11 | #endif	// PLATFORM_ANDROID


--------------------------------------------------------------------------------
/Core/STL/OS/Base/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Containers/String.h"
 6 | #include "Core/STL/Containers/Array.h"
 7 | #include "Core/STL/Containers/StaticArray.h"
 8 | #include "Core/STL/Types/Ptr.h"
 9 | #include "Core/STL/Time/Time.h"
10 | #include "Core/STL/Algorithms/Enum.h"
11 | #include "Core/STL/Common/Cast.h"
12 | #include "Core/STL/Memory/MemFunc.h"
13 | #include "Core/STL/Types/Function.h"
14 | #include "Core/STL/Types/Noncopyable.h"
15 | #include "Core/STL/Types/DefferedType.h"
16 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Base/Endianes.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Common.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace OS
10 | {
11 | 
12 | 	inline bool IsBigEndian () noexcept
13 | 	{
14 | 		const union {
15 | 			uint i;
16 | 			char c[4];
17 | 		} bint = {0x01020304};
18 | 		return bint.c[0] == 1; 
19 | 	}
20 | 
21 | 	inline bool IsLittleEndian () {
22 | 		return not IsBigEndian();
23 | 	}
24 | 
25 | }	// OS
26 | }	// GX_STL
27 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Posix/OSPosix.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_BASE_POSIX
 8 | 
 9 | #include "Core/STL/OS/Base/Common.h"
10 | 
11 | #if defined( PLATFORM_SDL )
12 | #	include "Core/STL/OS/SDL/OS_SDL.h"
13 | #endif
14 | 
15 | 
16 | namespace GX_STL
17 | {
18 | namespace OS
19 | {
20 | 	using namespace GX_STL::GXTypes;
21 | 
22 | }	// OS
23 | }	// GX_STL
24 | 
25 | #endif	// PLATFORM_BASE_POSIX


--------------------------------------------------------------------------------
/Core/STL/OS/Posix/PosixHeader.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #define ulong linux_uint
 6 | 
 7 | //#include <linux/time.h>
 8 | #include <time.h>
 9 | #include <dlfcn.h>
10 | #include <pthread.h>
11 | #include <signal.h>
12 | #include <unistd.h>
13 | #include <semaphore.h>
14 | //#include <errno.h>
15 | 
16 | #include <dirent.h>
17 | #include <sys/vfs.h>
18 | #include <unistd.h>
19 | #include <sys/types.h>
20 | #include <sys/stat.h>
21 | #include <sys/time.h>
22 | #include <unistd.h>
23 | #include <stdio.h>
24 | #include <fcntl.h>
25 | 
26 | #undef ulong
27 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Posix/PosixPlatformUtils.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_BASE_POSIX
 8 | 
 9 | #include "Core/STL/OS/Posix/OSPosix.h"
10 | 
11 | namespace GX_STL
12 | {
13 | namespace OS
14 | {
15 | 
16 | 	//
17 | 	// OS Utils
18 | 	//
19 | 
20 | 	struct PlatformUtils final : public Noninstancable
21 | 	{
22 | 		static void OpenURL (StringCRef url);
23 | 		
24 | 		static void IDEConsoleMessage (StringCRef message, StringCRef file, int line) {}
25 | 
26 | 		struct Dialog
27 | 		{
28 | 			enum class EResult
29 | 			{
30 | 				Unknown = -1,
31 | 				Skip	= 0,	// skip only this message
32 | 				Ignore,			// skip some messages in first 10 seconds
33 | 				Retry,			// run debugger
34 | 				Abort,			// exit from application
35 | 			};
36 | 
37 | 			static EResult ShowAssertion (StringCRef caption, StringCRef msg, StringCRef file, int line) { return Uninitialized; }
38 | 		};
39 | 	};
40 | 
41 | 	
42 | 	inline void PlatformUtils::OpenURL (StringCRef url)
43 | 	{
44 | 		TODO( "OpenURL" );
45 | 	}
46 | 
47 | 
48 | }	// OS
49 | }	// GX_STL
50 | 
51 | #endif	// PLATFORM_BASE_POSIX


--------------------------------------------------------------------------------
/Core/STL/OS/Posix/PosixRandDevice.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_BASE_POSIX
 8 | 
 9 | #include "Core/STL/OS/Posix/OSPosix.h"
10 | 
11 | namespace GX_STL
12 | {
13 | namespace OS
14 | {
15 | 
16 | 	//
17 | 	// Random Device
18 | 	//
19 | 
20 | 	struct PlatformRandomDevice final : public Noncopyable
21 | 	{
22 | 	// variables
23 | 	private:
24 | 		int		_fd;
25 | 
26 | 
27 | 	// methods
28 | 	public:
29 | 		PlatformRandomDevice (StringCRef provider);
30 | 		~PlatformRandomDevice ();
31 | 
32 | 		template <typename T>
33 | 		bool Generate (OUT T &value) const
34 | 		{
35 | 			return _Generate( Cast<char *>(AddressOf( value )), sizeof(value) );
36 | 		}
37 | 
38 | 	private:
39 | 		bool _Create (StringCRef provider);
40 | 		bool _CreateDefault ();
41 | 
42 | 		bool _Generate (char *ptr, usize size) const;
43 | 	};
44 | 
45 | 	
46 | }	// OS
47 | }	// GX_STL
48 | 
49 | #endif	// PLATFORM_BASE_POSIX
50 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Posix/PosixTimer.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | #include "Core/Config/STL.Config.h"
 7 | 
 8 | #if defined( PLATFORM_BASE_POSIX ) and defined( GX_USE_NATIVE_API )
 9 | 
10 | #include "Core/STL/OS/Posix/OSPosix.h"
11 | #include "Core/STL/OS/Base/Date.h"
12 | 
13 | namespace GX_STL
14 | {
15 | namespace OS
16 | {
17 | 
18 | 	//
19 | 	// Performance Timer
20 | 	//
21 | 	
22 | 	struct PerformanceTimer final : public Noncopyable
23 | 	{
24 | 	// methods
25 | 	public:
26 | 
27 | 		// seconds
28 | 		ND_ TimeD  GetTime () const;
29 | 
30 | 		// microseconds
31 | 		ND_ TimeL  GetTimeMicroSec () const;
32 | 
33 | 		template <typename T>
34 | 		ND_ T  Get (const T& = T()) const;
35 | 	};
36 | 	
37 | 
38 | 	template <>
39 | 	inline TimeL  PerformanceTimer::Get (const TimeL &) const
40 | 	{
41 | 		return GetTimeMicroSec();
42 | 	}
43 | 	
44 | 	template <>
45 | 	inline TimeD  PerformanceTimer::Get (const TimeD &) const
46 | 	{
47 | 		return GetTime();
48 | 	}
49 | 
50 | 
51 | }	// OS
52 | }	// GX_STL
53 | 
54 | #endif	// PLATFORM_BASE_POSIX and GX_USE_NATIVE_API
55 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/OS_SDL.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | #include "Core/STL/OS/Base/Common.h"
10 | 
11 | # ifdef COMPILER_MSVC
12 | #	pragma warning (push)
13 | #	pragma warning (disable: 4005)	// macros redefinition
14 | #	pragma warning (disable: 4668)	// '...' is not defined as a preprocessor macro
15 | # endif
16 | 
17 | #	define SDL_MAIN_HANDLED
18 | #	include "SDL2/include/SDL.h"
19 | 
20 | # ifdef COMPILER_MSVC
21 | #	pragma warning (pop)
22 | # endif
23 | 
24 | 
25 | namespace GX_STL
26 | {
27 | namespace OS
28 | {
29 | 
30 | }	// OS
31 | }	// GX_STL
32 | 
33 | #endif	// PLATFORM_SDL
34 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/SDLFileSystem.h:
--------------------------------------------------------------------------------
1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
2 | 
3 | #pragma once
4 | 
5 | #include "Core/STL/OS/Posix/PosixFileSystem.h"
6 | #include "Core/STL/OS/Windows/WinFileSystem.h"
7 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/SDLLibrary.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | #include "Core/STL/OS/SDL/OS_SDL.h"
10 | #include "Core/STL/OS/Base/BaseFileSystem.h"
11 | 
12 | namespace GX_STL
13 | {
14 | 	using SharedLibFunction_t 	= void (*) ();
15 | 
16 | namespace OS
17 | {
18 | 
19 | 	//
20 | 	// Library
21 | 	//
22 | 
23 | 	struct Library
24 | 	{
25 | 	// types
26 | 	public:
27 | 		using Func_t	= SharedLibFunction_t;
28 | 
29 | 
30 | 	// variables
31 | 	private:
32 | 		void *		_handle;
33 | 		String		_name;
34 | 		bool		_freeWhenDelete;
35 | 
36 | 
37 | 	// methods
38 | 	public:
39 | 		explicit Library (StringCRef name, bool canFree = true);
40 | 
41 | 		Library ();
42 | 		~Library ();
43 | 
44 | 		bool FindAndLoad (StringCRef name, uint searchDepth, bool canFree = true);
45 | 		bool Load (StringCRef name, bool canFree = true);
46 | 		void Unload ();
47 | 
48 | 		ND_ bool		IsValid () const	{ return _handle != null; }
49 | 
50 | 		ND_ StringCRef	GetName () const	{ return _name; }
51 | 
52 | 		ND_ Func_t		GetProc (StringCRef name, Func_t defProc = null) const;
53 | 
54 | 		template <typename T>
55 | 		bool GetProc (OUT T &func, StringCRef name)
56 | 		{
57 | 			func = ReferenceCast<T>( GetProc( name ) );
58 | 			return func != null;
59 | 		}
60 | 	};
61 | 
62 | }	// OS
63 | }	// GX_STL
64 | 
65 | #endif	// PLATFORM_SDL
66 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/SDLPlatformUtils.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Core/STL/Common/Platforms.h"
 4 | 
 5 | #if defined( PLATFORM_SDL )
 6 | 
 7 | #include "Core/STL/OS/SDL/SDLPlatformUtils.h"
 8 | #include "Core/STL/Log/ToString.h"
 9 | 
10 | namespace GX_STL
11 | {
12 | namespace OS
13 | {
14 | 	
15 | /*
16 | =================================================
17 | 	_CheckError
18 | =================================================
19 | */
20 | 	bool SDLUtils::_CheckError (StringCRef sdlCall, StringCRef func, StringCRef file, int line)
21 | 	{
22 | 		StringCRef	err = ::SDL_GetError();
23 | 
24 | 		if ( err.Empty() )
25 | 			return true;
26 | 		
27 | 		String	str("SDL error: ");
28 | 		
29 | 		str << err << "\n in " << sdlCall << ", function " << func;
30 | 
31 | 		LOG( str, ELog::Warning, file.cstr(), line );
32 | 
33 | 		::SDL_ClearError();
34 | 		return false;
35 | 	}
36 | 
37 | 
38 | }	// OS
39 | }	// GX_STL
40 | 
41 | #endif	// PLATFORM_SDL
42 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/SDLRandDevice.h:
--------------------------------------------------------------------------------
1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
2 | 
3 | #pragma once
4 | 
5 | #include "Core/STL/OS/Windows/WinRandDevice.h"
6 | #include "Core/STL/OS/Posix/PosixRandDevice.h"
7 | 


--------------------------------------------------------------------------------
/Core/STL/OS/SDL/SDLTimer.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | #include "Core/STL/OS/SDL/OS_SDL.h"
10 | #include "Core/STL/OS/Base/Date.h"
11 | #include "Core/STL/OS/Windows/WinTimer.h"
12 | #include "Core/STL/OS/Posix/PosixTimer.h"
13 | 
14 | namespace GX_STL
15 | {
16 | namespace OS
17 | {
18 | 	
19 | 	//
20 | 	// Performance Timer
21 | 	//
22 | 
23 | 	struct PerformanceTimer
24 | 	{
25 | 	private:
26 | 		ulong	_freq;
27 | 
28 | 	public:
29 | 		PerformanceTimer ()
30 | 		{
31 | 			_freq = ::SDL_GetPerformanceFrequency();
32 | 		}
33 | 
34 | 		// seconds
35 | 		ND_ forceinline TimeD  GetTime () const
36 | 		{
37 | 			return TimeD::FromSeconds( double(::SDL_GetPerformanceCounter()) / _freq );
38 | 		}
39 | 
40 | 		// microseconds
41 | 		ND_ forceinline TimeL  GetTimeMicroSec () const
42 | 		{
43 | 			return TimeL().FromTime( GetTime() );
44 | 		}
45 | 
46 | 		template <typename T>
47 | 		ND_ T  Get (const T& = T()) const;
48 | 	};
49 | 	
50 | 
51 | 	template <>
52 | 	forceinline TimeL  PerformanceTimer::Get (const TimeL &) const
53 | 	{
54 | 		return GetTimeMicroSec();
55 | 	}
56 | 	
57 | 	template <>
58 | 	forceinline TimeD  PerformanceTimer::Get (const TimeD &) const
59 | 	{
60 | 		return GetTime();
61 | 	}
62 | 
63 | 
64 | }	// OS
65 | }	// GX_STL
66 | 
67 | #endif	// PLATFORM_SDL


--------------------------------------------------------------------------------
/Core/STL/OS/Windows/OSWindows.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_WINDOWS
 8 | 
 9 | #include "Core/STL/OS/Base/Common.h"
10 | 
11 | #if defined( PLATFORM_SDL )
12 | #	include "Core/STL/OS/SDL/OS_SDL.h"
13 | #endif
14 | 
15 | 
16 | namespace GX_STL
17 | {
18 | namespace OS
19 | {
20 | 	
21 | }	// OS
22 | }	// GX_STL
23 | 
24 | #endif	// PLATFORM_WINDOWS
25 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Windows/WinHeader.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | //#define NOMINMAX
 6 | //#define NOMCX
 7 | //#define NOIME
 8 | //#define NOSERVICE
 9 | //#define WIN32_LEAN_AND_MEAN
10 | 
11 | #define Rectangle	WinRectangle
12 | #define byte		WinByte
13 | 
14 | #ifdef COMPILER_MSVC
15 | #	pragma warning (push, 0)
16 | #	include <Windows.h>
17 | #	pragma warning (pop)
18 | #else
19 | #	include <Windows.h>
20 | #endif
21 | 
22 | #undef DeleteFile
23 | #undef SetCurrentDirectory
24 | #undef GetCurrentDirectory
25 | #undef CreateDirectory
26 | #undef CreateFile
27 | #undef CopyFile
28 | #undef MoveFile
29 | #undef Yield
30 | #undef GetFreeSpace
31 | #undef CreateSemaphore
32 | #undef GetCurrentTime
33 | #undef min
34 | #undef max
35 | #undef CreateEvent
36 | #undef FindWindow
37 | #undef Rectangle
38 | #undef byte
39 | #undef VOID
40 | //#undef COMPOUND
41 | 
42 | using VOID = void;
43 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Windows/WinRandDevice.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_WINDOWS
 8 | 
 9 | #include "Core/STL/OS/Windows/OSWindows.h"
10 | 
11 | namespace GX_STL
12 | {
13 | namespace OS
14 | {
15 | 
16 | 	//
17 | 	// Random Device
18 | 	//
19 | 
20 | 	struct PlatformRandomDevice final : public Noncopyable
21 | 	{
22 | 	// types
23 | 	private:
24 | 		typedef DeferredTypeFrom< usize >	Handle_t;	// HCRYPTPROV
25 | 
26 | 
27 | 	// variables
28 | 	private:
29 | 		Handle_t	_prov;
30 | 
31 | 
32 | 	// methods
33 | 	public:
34 | 		explicit
35 | 		PlatformRandomDevice (StringCRef provider);
36 | 		~PlatformRandomDevice ();
37 | 
38 | 
39 | 		template <typename T>
40 | 		bool Generate (OUT T &value) const
41 | 		{
42 | 			return _Generate( Cast<ubyte *>(&value), sizeof(value) );
43 | 		}
44 | 
45 | 
46 | 	private:
47 | 		bool _CreateFromProviderName (StringCRef provider);
48 | 		bool _CreateFromType (uint type);
49 | 
50 | 		bool _CreateDefault ();
51 | 		bool _CreateDefault2 ();
52 | 
53 | 		bool _Generate (ubyte *ptr, usize size) const;
54 | 	};
55 | 	
56 | 	
57 | }	// OS
58 | }	// GX_STL
59 | 
60 | #endif	// PLATFORM_WINDOWS
61 | 


--------------------------------------------------------------------------------
/Core/STL/OS/Windows/WinTimer.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | #include "Core/Config/STL.Config.h"
 7 | 
 8 | #if defined( PLATFORM_WINDOWS ) and defined( GX_USE_NATIVE_API )
 9 | 
10 | #include "Core/STL/OS/Windows/OSWindows.h"
11 | #include "Core/STL/OS/Base/Date.h"
12 | 
13 | namespace GX_STL
14 | {
15 | namespace OS
16 | {
17 | 	
18 | 
19 | 	//
20 | 	// Performance Timer
21 | 	//
22 | 
23 | 	struct PerformanceTimer final : public Noncopyable
24 | 	{
25 | 	// types
26 | 	private:
27 | 		using Handle_t = DeferredTypeFrom< ulong >;	// LARGE_INTEGER
28 | 
29 | 
30 | 	// variables
31 | 	private:
32 | 		Handle_t	_liFreq;
33 | 
34 | 
35 | 	// methods
36 | 	public:
37 | 		PerformanceTimer ();
38 | 
39 | 		// seconds
40 | 		ND_ TimeD  GetTime () const;
41 | 
42 | 		// microseconds
43 | 		ND_ TimeL  GetTimeMicroSec () const;
44 | 
45 | 		template <typename T>
46 | 		ND_ T  Get (const T& = T()) const;
47 | 	};
48 | 	
49 | 
50 | 	template <>
51 | 	forceinline TimeL  PerformanceTimer::Get (const TimeL &) const
52 | 	{
53 | 		return GetTimeMicroSec();
54 | 	}
55 | 	
56 | 	template <>
57 | 	forceinline TimeD  PerformanceTimer::Get (const TimeD &) const
58 | 	{
59 | 		return GetTime();
60 | 	}
61 | 
62 | 
63 | }	// OS
64 | }	// GX_STL
65 | 
66 | #endif	// PLATFORM_WINDOWS and GX_USE_NATIVE_API


--------------------------------------------------------------------------------
/Core/STL/ThreadSafe/AtomicFlag.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | #ifdef GX_ATOMIC_SUPPORTED
 8 | 
 9 | namespace GX_STL
10 | {
11 | namespace GXTypes
12 | {
13 | 
14 | 	//
15 | 	// Atomic Flag
16 | 	//
17 | 
18 | 	struct AtomicFlag final
19 | 	{
20 | 	// types
21 | 	public:
22 | 		using Self		= AtomicFlag;
23 | 		using Value_t	= bool;
24 | 
25 | 
26 | 	// variables
27 | 	private:
28 | 		std::atomic<Value_t>	_flag;
29 | 
30 | 
31 | 	// methods
32 | 	public:
33 | 		AtomicFlag () = default;
34 | 		AtomicFlag (const Value_t& value) : _flag{ value } {}
35 | 
36 | 		AtomicFlag (AtomicFlag &&) = delete;
37 | 		AtomicFlag (const AtomicFlag &) = delete;
38 | 
39 | 		AtomicFlag& operator = (AtomicFlag &&) = delete;
40 | 		AtomicFlag& operator = (const AtomicFlag &) = delete;
41 | 
42 | 
43 | 		// fast
44 | 		void operator = (Value_t value)				{ _flag.store( value, std::memory_order_relaxed ); }
45 | 
46 | 		ND_ explicit operator Value_t () const		{ return _flag.load( std::memory_order_relaxed ); }
47 | 
48 | 
49 | 		// slower
50 | 		void		StoreAndSync (Value_t value)	{ _flag.store( value, std::memory_order_release ); }
51 | 
52 | 		ND_ Value_t	SyncAndLoad () const			{ return _flag.load( std::memory_order_acquire ); }
53 | 	};
54 | 
55 | 
56 | }	// GXTypes
57 | }	// GX_STL
58 | 
59 | #endif	// GX_ATOMIC_SUPPORTED
60 | 


--------------------------------------------------------------------------------
/Core/STL/Time/TimeProfiler.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Math/MathFunc.h"
 6 | #include "Core/STL/Containers/String.h"
 7 | #include "Core/STL/OS/OSLowLevel.h"
 8 | 
 9 | namespace GX_STL
10 | {
11 | namespace GXTypes
12 | {
13 | 	
14 | 	template <typename T>
15 | 	struct TimeProfiler;
16 | 
17 | #	define _TIME_PROFILER_IMPL_
18 | 
19 | #	define T	double
20 | #	include "FloatTimeImpl.h"
21 | 
22 | #	define T	float
23 | #	include "FloatTimeImpl.h"
24 | 
25 | #	define T	int
26 | #	include "IntTimeImpl.h"
27 | 
28 | #	define T	uint
29 | #	include "IntTimeImpl.h"
30 | 	
31 | #	define T	ilong
32 | #	include "IntTimeImpl.h"
33 | 
34 | #	define T	ulong
35 | #	include "IntTimeImpl.h"
36 | 
37 | #	undef _TIME_PROFILER_IMPL_
38 | 
39 | 
40 | 	using TimeProfilerF		= TimeProfiler<float>;
41 | 	using TimeProfilerD		= TimeProfiler<double>;
42 | 	using TimeProfilerU		= TimeProfiler<uint>;
43 | 	using TimeProfilerL		= TimeProfiler<ilong>;
44 | 	using TimeProfilerUL	= TimeProfiler<ulong>;
45 | 
46 | }	// GXTypes
47 | }	// GX_STL
48 | 


--------------------------------------------------------------------------------
/Core/STL/Types/Noncopyable.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/CompileTime/TypeQualifier.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 
12 | 	//
13 | 	// Non-copyable base class
14 | 	//
15 | 
16 | 	class Noncopyable : public CompileTime::TypeQualifier< CompileTime::ETypeQualifier::Def_Noncopyable >
17 | 	{
18 | 	public:
19 | 		Noncopyable () {}
20 | 
21 | 		~Noncopyable () {}
22 | 
23 | 	private:
24 | 		explicit Noncopyable (const Noncopyable &) = delete;
25 | 		explicit Noncopyable (Noncopyable &&) = delete;
26 | 
27 | 		Noncopyable& operator = (const Noncopyable &) = delete;
28 | 		Noncopyable& operator = (Noncopyable &&) = delete;
29 | 	};
30 | 
31 | 
32 | }	// GXTypes
33 | }	// GX_STL
34 | 


--------------------------------------------------------------------------------
/Core/STL/Types/Noninstancable.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Types.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 
12 | 	//
13 | 	// Non-instancable base class
14 | 	//
15 | 
16 | 	class Noninstancable
17 | 	{
18 | 	protected:
19 | 		Noninstancable () = delete;
20 | 
21 | 		//~Noninstancable () = delete;
22 | 
23 | 		Noninstancable (const Noninstancable &) = delete;
24 | 
25 | 		Noninstancable (Noninstancable &&) = delete;
26 | 
27 | 		Noninstancable& operator = (const Noninstancable &) = delete;
28 | 
29 | 		Noninstancable& operator = (Noninstancable &&) = delete;
30 | 	};
31 | 
32 | 
33 | }	// GXTypes
34 | }	// GX_STL
35 | 


--------------------------------------------------------------------------------
/Core/STL/Types/ScopeSetter.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Types/Noncopyable.h"
 6 | 
 7 | namespace GX_STL
 8 | {
 9 | namespace GXTypes
10 | {
11 | 
12 | 	//
13 | 	// Scope Setter
14 | 	//
15 | 
16 | 	template <typename T>
17 | 	struct ScopeSetter : Noncopyable
18 | 	{
19 | 	// variables
20 | 	private:
21 | 		T &			_ref;
22 | 		const T		_value;
23 | 
24 | 
25 | 	// methods
26 | 	public:
27 | 		ScopeSetter (INOUT T &ref, const T &value) : _ref( ref ), _value( value )
28 | 		{}
29 | 
30 | 		~ScopeSetter ()
31 | 		{
32 | 			_ref = _value;
33 | 		}
34 | 	};
35 | 	
36 | #	define SCOPE_SETTER( _valueRef_, _newValue_ ) \
37 | 		GX_STL::OS::ScopeSetter< TypeTraits::RemoveAnyReference< decltype(_valueRef_) > >	AUXDEF_UNITE_RAW( __scopeSetter, __COUNTER__ ) ( _valueRef_, _newValue_ )
38 | 
39 | 
40 | }	// GXTypes
41 | }	// GX_STL
42 | 


--------------------------------------------------------------------------------
/Core/STL/Types/UntypedKey.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Types/Ptr.h"
 6 | #include "Core/STL/Types/SharedPointer.h"
 7 | #include "Core/STL/Types/WeakPointer.h"
 8 | 
 9 | namespace GX_STL
10 | {
11 | namespace GXTypes
12 | {
13 | 
14 | 	namespace _types_hidden_
15 | 	{
16 | 
17 | 		template <typename T>
18 | 		struct _UntypedKey;
19 | 
20 | 		template <typename T>		struct _UntypedKey< T* >			{ using type = void const *; };
21 | 		template <typename T>		struct _UntypedKey< T const * >		{ using type = void const *; };
22 | 
23 | 		template <typename T>		struct _UntypedKey< Ptr<T> >		{ using type = void const *; };
24 | 		
25 | 		template <typename T, typename B, typename S>					struct _UntypedKey< SharedPointer<T,B,S> >		{ using type = void const *; };
26 | 		
27 | 		template <typename T, typename B, typename WS, typename SPS>	struct _UntypedKey< WeakPointer<T,B,WS,SPS> >	{ using type = void const *; };
28 | 
29 | 	}	// _types_hidden_
30 | 
31 | 
32 | 	template <typename T>
33 | 	using UntypedKey  = typename _types_hidden_::_UntypedKey< T >::type;
34 | 
35 | 
36 | }	// GXTypes
37 | }	// GX_STL
38 | 


--------------------------------------------------------------------------------
/Core/Script/Core.Script.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Script/Impl/ScriptEngine.h"
 6 | #include "Core/Script/Impl/ScriptEngine.inl.h"
 7 | #include "Core/Script/Impl/ScriptModule.h"
 8 | 
 9 | #include "Core/Script/Impl/ClassBinder.h"
10 | #include "Core/Script/Impl/EnumBinder.h"
11 | 


--------------------------------------------------------------------------------
/CoreTests/Physics/Common.h:
--------------------------------------------------------------------------------
1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
2 | 
3 | #pragma once
4 | 
5 | #include "Core/Physics/Core.Physics.h"
6 | 
7 | #define TEST	CHECK_FATAL
8 | 


--------------------------------------------------------------------------------
/CoreTests/Physics/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Physics/Common.h"
 4 | #include "Core/STL/Log/Logger.h"
 5 | 
 6 | extern void Test_Dimensions_PhysicsValue ();
 7 | extern void Test_Algorithms_Orbit ();
 8 | 
 9 | using namespace GX_STL;
10 | using namespace GX_STL::GXTypes;
11 | using namespace GX_STL::GXMath;
12 | 
13 | int main ()
14 | {
15 | 	InitializeSTLMath();
16 | 
17 | 	Logger::GetInstance()->Open( "log", false );
18 | 
19 | 	Test_Dimensions_PhysicsValue();
20 | 
21 | 	Test_Algorithms_Orbit();
22 | 	
23 | 	LOG( "Tests Finished!", ELog::Info );
24 | 
25 | 	Logger::GetInstance()->Close();
26 | 	
27 | 	DEBUG_ONLY( DbgRefCountedObject::s_ChenckNotReleasedObjects() );
28 | 	DEBUG_ONLY( RefCounter2::s_CheckAllocations() );
29 | 
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/CoreTests/Physics/Test_Algorithms_Orbit.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Physics/Common.h"
 4 | #include "Core/Physics/Dimensions/DefaultTypes.h"
 5 | 
 6 | using namespace GXPhysics;
 7 | using namespace GXPhysics::Astrophysics;
 8 | 
 9 | 
10 | static void TestOrbit1 ()
11 | {
12 | 	Orbit<real>	o;
13 | 
14 | 	o.semiMajorAxis	= AstronomicalUnits( 1.0_r );
15 | 	o.orbitalPeriod	= Days( 365.256363004_r );
16 | 	o.longOfAscNode	= (Rad) Deg( 348.73936_r );
17 | 	o.inclination	= (Rad) Deg( 7.155_r );
18 | 	o.perihelionArg	= (Rad) Deg( 114.20783_r );
19 | 	o.eccentricity	= 0.01671123_r;
20 | 
21 | 	Orbit<real>::Position3_t	pos0, pos1, pos2, pos3, pos4;
22 | 	Orbit<real>::Length_t		len0, len1, len2, len3, len4;
23 | 
24 | 	o.Update( o.orbitalPeriod * 0.0_r );	pos0 = o.position;	len0 = pos0.Length();
25 | 	o.Update( o.orbitalPeriod * 0.25_r );	pos1 = o.position;	len1 = pos1.Length();	
26 | 	o.Update( o.orbitalPeriod * 0.5_r );	pos2 = o.position;	len2 = pos2.Length();
27 | 	o.Update( o.orbitalPeriod * 0.75_r );	pos3 = o.position;	len3 = pos3.Length();
28 | 	o.Update( o.orbitalPeriod * 1.0_r );	pos4 = o.position;	len4 = pos4.Length();
29 | 
30 | 	TEST( All(GXPhysics::Equals( pos0, pos4 )) );
31 | 	TEST( Equals( len0, len4 ) );
32 | 	TEST( Equals( len1, len3 ) );
33 | 	TEST( Equals( MiddleValue( len0, len2 ), o.semiMajorAxis ) );
34 | }
35 | 
36 | 
37 | extern void Test_Algorithms_Orbit ()
38 | {
39 | 	TestOrbit1();
40 | }
41 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Common.h:
--------------------------------------------------------------------------------
1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
2 | 
3 | #pragma once
4 | 
5 | #include "Core/STL/Core.STL.h"
6 | 
7 | #define TEST	CHECK_FATAL
8 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_CompileTime_Map.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::CompileTime;
 7 | 
 8 | 
 9 | extern void Test_CompileTime_Map ()
10 | {
11 | 	using map1 = CreateMap< int, ValueToType<int, 0> >;
12 | 	using map2 = map1::Add< float, ValueToType<int, 2> >;
13 | 
14 | 	STATIC_ASSERT( map2::Get< int >::value == 0 );
15 | 	STATIC_ASSERT( map2::Get< float >::value == 2 );
16 | 	STATIC_ASSERT( map2::GetValue< int > == 0 );
17 | }
18 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_CompileTime_StaticFloat.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::CompileTime;
 7 | 
 8 | 
 9 | extern void Test_CompileTime_StaticFloat ()
10 | {
11 | #ifdef GX_PHYSICS_DIMENSIONS_ENABLED
12 | 
13 | 	typedef StaticFloat< 1, 0 >		f0;
14 | 	typedef StaticFloat< 2, 0 >		f1;
15 | 
16 | 	STATIC_ASSERT( not f0::Equal< f1 >::value );
17 | 	STATIC_ASSERT( f0::NotEqual< f1 >::value );
18 | 	
19 | 	STATIC_ASSERT( f0::FastEqual< f0 >::value );
20 | 	STATIC_ASSERT( not f0::FastEqual< f1 >::value );
21 | 
22 | 	STATIC_ASSERT( f0::LessThan< f1 >::value );
23 | 
24 | 	typedef f1::Div< f0 >	f2;
25 | 	STATIC_ASSERT( f2::Equal< f1 >::value );
26 | 
27 | #endif	// GX_PHYSICS_DIMENSIONS_ENABLED
28 | }
29 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Containers_IndexedArray.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | 
 8 | 
 9 | static void IndexedArray_Test1 ()
10 | {
11 | 	IndexedArray<int>	arr;
12 | 
13 | 	arr << 0 << 5 << 8 << 3 << 11 << 1 << 7 << 3 << 5 << 99 << 4 << 66 << 8;
14 | 
15 | 	arr.Sort();
16 | 
17 | 	FORv( i, 1, arr ) {
18 | 		TEST( arr[i-1] <= arr[i] );
19 | 	}
20 | }
21 | 
22 | 
23 | static void IndexedArray_Test2 ()
24 | {
25 | 	using IMap	= _types_hidden_::BaseMap< IndexedArray, int, float, true, AutoDetectCopyStrategy<Pair<int, float>>::type, MemoryContainer<Pair<int, float>> >;
26 | 
27 | 	IMap	m;
28 | 
29 | 	m.Add( 0, 8.0f );
30 | 	m.Add( 4, 5.0f );
31 | 	m.Add( 2, 6.3f );
32 | 	m.Add( 3, 7.0f );
33 | 
34 | 	TEST( m( 0 ) == 8.0f );
35 | 	TEST( m( 4 ) == 5.0f );
36 | 	TEST( m( 2 ) == 6.3f );
37 | 	TEST( m( 3 ) == 7.0f );
38 | }
39 | 
40 | 
41 | extern void Test_Containers_IndexedArray ()
42 | {
43 | 	IndexedArray_Test1();
44 | 	IndexedArray_Test2();
45 | }
46 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Containers_List.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | 
 8 | 
 9 | extern void Test_Containers_List ()
10 | {
11 | 	//List<int>	list;
12 | }
13 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Containers_Tuple.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | 
 8 | 
 9 | static void TupleTest1 ()
10 | {
11 | 	using T0 = Tuple< int >;
12 | 
13 | 	T0	t { 1 };
14 | 
15 | 	TEST( t.Get<0>() == 1 );
16 | 	TEST( t.Count() == 1 );
17 | }
18 | 
19 | static void TupleTest2 ()
20 | {
21 | 	using T0 = Tuple< int, float >;
22 | 
23 | 	T0	t { 1, 2.0f };
24 | 
25 | 	TEST( t.Get<0>() == 1 );
26 | 	TEST( t.Get<1>() == 2.0f );
27 | 	TEST( t.Count() == 2 );
28 | }
29 | 
30 | static void TupleTest3 ()
31 | {
32 | 	using T0 = Tuple< CompileTime::TypeListFrom< int, float, double > >;
33 | 
34 | 	T0	t { 1, 2.0f, 3.0 };
35 | 
36 | 	TEST( t.Get<0>() == 1 );
37 | 	TEST( t.Get<1>() == 2.0f );
38 | 	TEST( t.Get<2>() == 3.0 );
39 | 	TEST( t.Count() == 3 );
40 | }
41 | 
42 | static void TupleTest4 ()
43 | {
44 | 	using T0 = Tuple< int, float >;
45 | 
46 | 	T0	t {};
47 | 
48 | 	TEST( t.Get<0>() == 0 );
49 | 	TEST( t.Get<1>() == 0.0f );
50 | 	TEST( t.Count() == 2 );
51 | 
52 | 	T0	t2 { 1, 2.0f };
53 | 	t = t2;
54 | 
55 | 	TEST( t.Get<0>() == 1 );
56 | 	TEST( t.Get<1>() == 2.0f );
57 | }
58 | 
59 | 
60 | extern void Test_Containers_Tuple ()
61 | {
62 | 	TupleTest1();
63 | 	TupleTest2();
64 | 	TupleTest3();
65 | 	TupleTest4();
66 | }
67 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_Abs.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | extern void Test_Math_Abs ()
11 | {
12 | 	TEST( Abs( -100 ) == 100 );
13 | 	TEST( Abs( 5 ) == 5 );
14 | 	TEST( Abs( MinValue<int>() ) >= 0 );
15 | 	TEST( Abs( MaxValue<int>() ) == MaxValue<int>() );
16 | 
17 | 	TEST( Abs( -3.0f ) == 3.0f );
18 | 	TEST( Abs( MinValue<float>() ) >= 0.0f );
19 | }
20 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_Color.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | extern void Test_Math_Color ()
11 | {
12 | 	color4u c;
13 | 	ubyte R = 0x11;
14 | 	ubyte G = 0x22;
15 | 	ubyte B = 0x33;
16 | 	ubyte A = 0x44;
17 | 
18 | 	c.FromIntRGB( (R<<16) | (G<<8) | B );
19 | 	TEST( c.R() == R );
20 | 	TEST( c.G() == G );
21 | 	TEST( c.B() == B );
22 | 	
23 | 	c.FromIntRGBA( (R<<24) | (G<<16) | (B<<8) | A );
24 | 	TEST( c.R() == R );
25 | 	TEST( c.G() == G );
26 | 	TEST( c.B() == B );
27 | 	TEST( c.A() == A );
28 | 	
29 | 	c.FromIntABGR( (A<<24) | (B<<16) | (G<<8) | R );
30 | 	TEST( c.R() == R );
31 | 	TEST( c.G() == G );
32 | 	TEST( c.B() == B );
33 | 	TEST( c.A() == A );
34 | 	
35 | 	c.FromIntARGB( (A<<24) | (R<<16) | (G<<8) | B );
36 | 	TEST( c.R() == R );
37 | 	TEST( c.G() == G );
38 | 	TEST( c.B() == B );
39 | 	TEST( c.A() == A );
40 | }
41 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_Factorial.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | extern void Test_Math_Factorial ()
11 | {
12 | 	double	res;
13 | 
14 | 	res = IntFactorial( 4.0 );					TEST( Equals( res, 24.0 ) );
15 | 	res = FastFactorial( 4.0 );					TEST( Equals( res, 24.0 ) );
16 | 	res = FastApproximatedFactorial( 4.0 );		TEST( RoundToInt( res ) == 24 );
17 | 	res = IntSuperFactorial( 4.0 );				TEST( Equals( res, 288.0 ) );
18 | 	res = IntHyperFactorial( 4.0 );				TEST( Equals( res, 27648.0 ) );
19 | 	res = IntDoubleFactorial( 9.0 );			TEST( Equals( res, 945.0 ) );
20 | 	res = IntGammaFunction( 5.0 );				TEST( Equals( res, 24.0 ) );
21 | 	//res = LnGammaFunction( 5.0 );				TEST( Equals(); );
22 | 	res = FastGammaFunction( 5.0 );				TEST( Equals( res, 24.0 ) );
23 | 	res = FastLnGammaFunction( 0.5 );			TEST( Equals( res, 0.572365 ) );
24 | 	res = FastGammaFunction( 0.5 );				TEST( Equals( res, 1.772454 ) );
25 | }
26 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_FloorCeilTruncRoundFract.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | extern void Test_Math_FloorCeilTruncRoundFract ()
11 | {
12 | 	float a0 = Floor( 3.45f );		TEST( Equals( a0, 3.0f ) );
13 | 	float a1 = Floor( -3.45f );		TEST( Equals( a1, -4.0f ) );
14 | 	
15 | 	float b0 = Ceil( 3.45f );		TEST( Equals( b0, 4.0f ) );
16 | 	float b1 = Ceil( -3.45f );		TEST( Equals( b1, -3.0f ) );
17 | 
18 | 	float c0 = Round( 3.45f );		TEST( Equals( c0, 3.0f ) );
19 | 	float c1 = Round( 3.55f );		TEST( Equals( c1, 4.0f ) );
20 | 	float c2 = Round( -3.45f );		TEST( Equals( c2, -3.0f ) );
21 | 	float c3 = Round( -3.55f );		TEST( Equals( c3, -4.0f ) );
22 | 	
23 | 	float d0 = Fract( 3.45f );		TEST( Equals( d0, 0.45f ) );
24 | 	float d1 = Fract( -3.55f );		TEST( Equals( d1, 0.45f ) );
25 | 
26 | 	float e0 = Trunc( 3.45f );		TEST( Equals( e0, 3.0f ) );
27 | 	float e1 = Trunc( -3.45f );		TEST( Equals( e1, -3.0f ) );
28 | }
29 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_OverflowCheck.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath::OverflowChecker;
 8 | 
 9 | 
10 | extern void Test_Math_OverflowCheck ()
11 | {
12 | 	TEST( not AdditionIsSafe( MinValue<int>() +  10,  -11 ) );
13 | 	TEST(     AdditionIsSafe( MinValue<int>() + 100, -100 ) );
14 | 	TEST(     AdditionIsSafe( MinValue<int>() + 100,  -99 ) );
15 | 	
16 | 	TEST( not AdditionIsSafe( MaxValue<int>() -  10,  11 ) );
17 | 	TEST(     AdditionIsSafe( MaxValue<int>() - 100, 100 ) );
18 | 	TEST(     AdditionIsSafe( MaxValue<int>() - 100,  99 ) );
19 | 	
20 | 	TEST( not SubtractionIsSafe( MinValue<int>() +  10,  11 ) );
21 | 	TEST(     SubtractionIsSafe( MinValue<int>() + 100, 100 ) );
22 | 	TEST(     SubtractionIsSafe( MinValue<int>() + 100,  99 ) );
23 | 	
24 | 	TEST( not SubtractionIsSafe( MaxValue<int>() -  10,  -11 ) );
25 | 	TEST(     SubtractionIsSafe( MaxValue<int>() - 100, -100 ) );
26 | 	TEST(     SubtractionIsSafe( MaxValue<int>() - 100,  -99 ) );
27 | 
28 | 	TEST( not AdditionIsSafe( MaxValue<uint>(),    1u ) );
29 | 	TEST(     AdditionIsSafe( MaxValue<uint>()-1,  1u ) );
30 | 	TEST(     AdditionIsSafe( MaxValue<uint>()-10, 9u ) );
31 | 	
32 | 	TEST( not SubtractionIsSafe( 10u,  11u ) );
33 | 	TEST(     SubtractionIsSafe( 10u,  10u ) );
34 | 	TEST(     SubtractionIsSafe( 10u,   9u ) );
35 | }
36 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Math_Plane.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | using plane	= Plane<float>;
10 | 
11 | 
12 | static void Test_Plane0 ()
13 | {
14 | 	plane	p0{ float3(0.0f), float3(0.0f, 1.0f, 0.0f), float3(1.0f, 0.0f, 1.0f) };
15 | 	plane	p1{ float3(0.0f), float3(0.0f, 1.0f, 0.0f), float3(-1.0f, 0.0f, 1.0f) };
16 | 
17 | 	float3	a1;
18 | 	bool	i1 = p0.GetIntersection( p1, OUT a1 );
19 | 	GX_UNUSED( i1 );
20 | 
21 | 	TEST( All( Equals( a1, float3(0.0f, -1.0f, 0.0f) ) ) );
22 | 
23 | 	float3	a0;
24 | 	bool	i0 = p0.GetIntersection( float3(1.0f, 0.0f, 0.0f).Normalized(), float3(-2.0f, 0.0f, 1.0f), OUT a0 );
25 | 	GX_UNUSED( i0 );
26 | 
27 | 	float3 n0, n1, n2;
28 | 	p0.GetPerpendiculars( n0, n1, n2 );
29 | }
30 | 
31 | 
32 | extern void Test_Math_Plane ()
33 | {
34 | 	Test_Plane0();
35 | }
36 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_OS_Atomic.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | void Test_Atomics_1 ()
11 | {
12 | 	Atomic<int>	a{ 0 };
13 | 
14 | 	int	a0 = a.Add( 10 );				TEST( a0 == 10 );
15 | 	int	a1 = a.Sub( 2 );				TEST( a1 == 8 );
16 | 	int	a2 = a.Inc();					TEST( a2 == 9 );
17 | 	int	a3 = a.Dec();					TEST( a3 == 8 );
18 | 	int	a4 = a.Or( 0x1234 );			TEST( a4 == 0x123C );
19 | 	int	a5 = a.And( 0x20F );			TEST( a5 == 0x20C );
20 | 	int	a6 = a.Xor( 0x210 );			TEST( a6 == 0x01C );
21 | 	int	a7 = a.Set( 22 );				TEST( a7 == 22 );
22 | 	int	a8 = a.CompareEx( 55, 22 );		TEST( a8 == 22 );
23 | 	int	a9 = a.CompareEx( 77, 22 );		TEST( a9 == 55 );
24 | }
25 | 
26 | 
27 | extern void Test_OS_Atomic ()
28 | {
29 | 	Test_Atomics_1();
30 | }
31 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_OS_FileSystem.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | 
 8 | 
 9 | static void TestGetAllFiles ()
10 | {
11 | 	Array<String>	dirs;
12 | 
13 | 	TEST( OS::FileSystem::GetAllDirsInPath( "..", dirs ) );
14 | 
15 | 	TEST( not dirs.Empty() );
16 | }
17 | 
18 | 
19 | static void TestFolderSearch ()
20 | {
21 | 	TEST( OS::FileSystem::FindAndSetCurrentDir( "CoreTests/Script", 4 ) );
22 | 
23 | 	TEST( OS::FileSystem::IsFileExist( "Main.cpp" ) );
24 | }
25 | 
26 | 
27 | static void TestRecursiveFileSearch ()
28 | {
29 | 	TEST( OS::FileSystem::FindAndSetCurrentDir( "CoreTests/STL", 4 ) );
30 | 
31 | 	Array<String>	file_names;
32 | 	auto			filter = LAMBDA()(StringCRef fname) -> bool
33 | 	{{
34 | 		StringCRef ext	= FileAddress::GetExtension( fname );
35 | 		StringCRef name	= FileAddress::GetName( fname );
36 | 
37 | 		return ext.EqualsIC( "cpp" ) and name.StartsWithIC( "Test_" );
38 | 	}};
39 | 
40 | 	OS::FileSystem::RecursiveFindFiles( "", filter, 1, OUT file_names );
41 | 
42 | 	usize	idx;
43 | 	TEST( file_names.Find( OUT idx, String("Test_OS_FileSystem.cpp"), 0 ) );
44 | }
45 | 
46 | 
47 | extern void Test_OS_FileSystem ()
48 | {
49 | 	TestGetAllFiles();
50 | 	TestFolderSearch();
51 | 	TestRecursiveFileSearch();
52 | }
53 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Runtime_VirtualTypelist.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::CompileTime;
 8 | using namespace GX_STL::Runtime;
 9 | 
10 | 
11 | extern void Test_Runtime_VirtualTypelist ()
12 | {
13 | 	using Typelist1 = TypeListFrom< int, float, ulong, bool >;
14 | 
15 | 	TypeIdList	vtl = TypeIdList( UninitializedT< Typelist1 >() );
16 | 
17 | 	TEST( vtl.HasType( TypeIdOf<float>() ) );
18 | }
19 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Temp.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	Temporary tests.
 4 | */
 5 | 
 6 | #include "CoreTests/STL/Common.h"
 7 | #include "Debug.h"
 8 | #include <array>
 9 | 
10 | using namespace GX_STL;
11 | using namespace GX_STL::GXTypes;
12 | using namespace GX_STL::GXMath;
13 | 
14 | 
15 | 
16 | extern void Test_Temp ()
17 | {
18 | 	int i = 0;
19 | 	
20 | 	auto& j = i;
21 | 
22 | 	const auto	lambda = [j] ()
23 | 	{
24 | 		STATIC_ASSERT( not TypeTraits::IsAnyReference< decltype(j) > );
25 | 
26 | 		LOG( typeid(j).raw_name(), ELog::Info );
27 | 	};
28 | 
29 | 	lambda();
30 | 
31 | 
32 | 	WARNING( "!!!" );
33 | }
34 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Types_Cast.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | 
 8 | 
 9 | extern void Test_Types_Cast ()
10 | {
11 | 	const float a = Cast<float>( 10 );
12 | 
13 | 	const int b = CompileTime::ValueToType< int, Cast<int>( 6u ) >::value;
14 | }
15 | 


--------------------------------------------------------------------------------
/CoreTests/STL/Test_Types_Time.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/STL/Common.h"
 4 | 
 5 | using namespace GX_STL;
 6 | using namespace GX_STL::GXTypes;
 7 | using namespace GX_STL::GXMath;
 8 | 
 9 | 
10 | extern void Test_Types_Time ()
11 | {
12 | 	uint	a0 = 1;
13 | 	TimeU	a1 = TimeU::FromSeconds( a0 );
14 | 	uint	a2 = a1.Seconds();
15 | 	TEST( a0 == a2 );
16 | 
17 | 	float	b0 = 1.2345f;
18 | 	TimeF	b1 = TimeF::FromSeconds( b0 );
19 | 	float	b2 = b1.Seconds();
20 | 	TEST( Equals( b0, b2 ) );
21 | }
22 | 


--------------------------------------------------------------------------------
/CoreTests/Script/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Script/Core.Script.h"
 6 | #include "Core/Script/Bindings/DefaultBindings.h"
 7 | #include "Core/STL/Log/Logger.h"
 8 | #include "Core/STL/Math/Interpolations.h"
 9 | #include "Core/STL/Math/BinaryMath.h"
10 | 
11 | #define TEST	CHECK_FATAL
12 | 
13 | 
14 | using namespace GXScript;
15 | using namespace GX_STL::GXMath;
16 | 


--------------------------------------------------------------------------------
/CoreTests/Script/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Script/Common.h"
 4 | 
 5 | //extern void Test_SimpleScript ();
 6 | 
 7 | extern void Test_ScriptClass ();
 8 | extern void Test_ScriptScalarMath ();
 9 | extern void Test_ScriptVectorMath ();
10 | extern void Test_ScriptString ();
11 | extern void Test_Eval ();
12 | 
13 | 
14 | int main ()
15 | {
16 | 	InitializeSTLMath();
17 | 
18 | 	Logger::GetInstance()->Open( "log", false );
19 | 
20 | 
21 | 	Test_ScriptClass();
22 | 	Test_ScriptScalarMath();
23 | 	Test_ScriptVectorMath();
24 | 	Test_ScriptString();
25 | 	Test_Eval();
26 | 
27 | 	
28 | 	LOG( "Tests Finished!", ELog::Info );
29 | 
30 | 	Logger::GetInstance()->Close();
31 | 	
32 | 	DEBUG_ONLY( DbgRefCountedObject::s_ChenckNotReleasedObjects() );
33 | 	DEBUG_ONLY( RefCounter2::s_CheckAllocations() );
34 | 
35 | 	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/CoreTests/Script/Test_Eval.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Script/Common.h"
 4 | 
 5 | class Script
 6 | {
 7 | public:
 8 | 	static ScriptEngine *	engine;
 9 | 
10 | 	int Run (int value)
11 | 	{
12 | 		const char	script[] = R"#(
13 | 			int main (int x) {
14 | 				return 10 + x;
15 | 			}
16 | 		)#";
17 | 
18 | 		ScriptModulePtr	mod = New<ScriptModule>( engine );
19 | 		mod->Create( "def1" );
20 | 
21 | 		int	res = 0;
22 | 		mod->Run( script, "main", OUT res, value );
23 | 
24 | 		return res;
25 | 	}
26 | };
27 | 
28 | ScriptEngine *	Script::engine = null;
29 | 
30 | 
31 | static void Test_ScriptInScript (ScriptEngine &se)
32 | {
33 | 	const char	script[] = R"#(
34 | 		int main ()
35 | 		{
36 | 			Script sc;
37 | 			return sc.Run( 1 );
38 | 		}
39 | 	)#";
40 | 
41 | 	Script::engine = &se;
42 | 
43 | 	ClassBinder<Script>		binder{ &se, "Script" };
44 | 
45 | 	binder.CreateClassValue();
46 | 	binder.AddMethod( &Script::Run, "Run" );
47 | 
48 | 
49 | 	int	res = 0;
50 | 	se.Run( script, "main", OUT res );
51 | 
52 | 	TEST( res == 11 );
53 | }
54 | 
55 | 
56 | extern void Test_Eval ()
57 | {
58 | 	ScriptEngine	se;
59 | 
60 | 	Test_ScriptInScript( se );
61 | }
62 | 


--------------------------------------------------------------------------------
/CoreTests/Script/Test_ScriptScalarMath.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Script/Common.h"
 4 | 
 5 | 
 6 | static void TestScalar_Sin (ScriptEngine *se)
 7 | {
 8 | 	const char	script[] = R"#(
 9 | 		float main () {
10 | 			float f = Sin( 3.14f );
11 | 			return f;
12 | 		}
13 | 	)#";
14 | 
15 | 	float	res = 0;
16 | 	se->Run( script, "main", OUT res );
17 | 
18 | 	const float	ref = Sin( 3.14_rad);
19 | 
20 | 	TEST( res == ref );
21 | }
22 | 
23 | 
24 | extern void Test_ScriptScalarMath ()
25 | {
26 | 	ScriptEngine	se;
27 | 
28 | 	DefaultBindings::BindScalarMath( &se );
29 | 
30 | 	TestScalar_Sin( &se );
31 | }
32 | 


--------------------------------------------------------------------------------
/CoreTests/Script/Test_ScriptVectorMath.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CoreTests/Script/Common.h"
 4 | 
 5 | 
 6 | static void TestVec_Float2Ctor (ScriptEngine *se)
 7 | {
 8 | 	const char	script[] = R"#(
 9 | 		float main () {
10 | 			float2 f = float2(1.0f, 2.0f);
11 | 			return f.x + f.y;
12 | 		}
13 | 	)#";
14 | 
15 | 	float	res = 0;
16 | 	se->Run( script, "main", OUT res );
17 | 
18 | 	TEST( res == 3.0f );
19 | }
20 | 
21 | static void TestVec_Float2Dot (ScriptEngine *se)
22 | {
23 | 	const char	script[] = R"#(
24 | 		float main () {
25 | 			float2 f1 = float2(1.0f, 2.0f);
26 | 			float2 f2 = float2(3.0f, 4.0f);
27 | 			float f = Dot( f1, f2 );
28 | 			return f;
29 | 		}
30 | 	)#";
31 | 
32 | 	float	res = 0;
33 | 	se->Run( script, "main", OUT res );
34 | 
35 | 	TEST( res == 11.0f );
36 | }
37 | 
38 | static void TestVec_Float3Cmp (ScriptEngine *se)
39 | {
40 | 	const char	script[] = R"#(
41 | 		int main () {
42 | 			float3 f1 = float3(1.0f, 2.0f, 3.0f);
43 | 			float3 f2 = float3(1.0f, 2.0f, 3.0f);
44 | 			bool3 bb = (f1 == f2);
45 | 			return All( bb ) ? 1 : 0;
46 | 		}
47 | 	)#";
48 | 
49 | 	int		res = 0;
50 | 	se->Run( script, "main", OUT res );
51 | 
52 | 	TEST( res == 1 );
53 | }
54 | 
55 | 
56 | extern void Test_ScriptVectorMath ()
57 | {
58 | 	ScriptEngine	se;
59 | 
60 | 	DefaultBindings::BindVectorMath( &se );
61 | 
62 | 	TestVec_Float2Ctor( &se );
63 | 	TestVec_Float2Dot( &se );
64 | 	TestVec_Float3Cmp( &se );
65 | }
66 | 


--------------------------------------------------------------------------------
/Engine/Base/Common/BaseObject.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	BaseObject - base class for all modules, systems and other engine classes.
 4 | 	BaseObject can be static or dynamic, for dynamic creation use static function,
 5 | 	which return shared pointer type, 'new' operator supported, but not safe.
 6 | */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Engine/Base/Common/Common.h"
11 | #include "Engine/Base/Common/EngineSubSystems.h"
12 | 
13 | 
14 | namespace Engine
15 | {
16 | namespace Base
17 | {
18 | 
19 | 	//
20 | 	// Base Object
21 | 	//
22 | 
23 | 	class BaseObject : public StaticRefCountedObject
24 | 	{
25 | 	// variables
26 | 	private:
27 | 		DEBUG_ONLY(
28 | 			String					_debugName;
29 | 		)
30 | 		const GlobalSystemsRef		_globalSystems;
31 | 
32 | 
33 | 	// methods
34 | 	public:
35 | 		explicit BaseObject (GlobalSystemsRef gs) :
36 | 			_globalSystems(gs)
37 | 		{}
38 | 
39 | 		ND_ GlobalSystemsRef	GlobalSystems ()	const	{ return _globalSystems; }
40 | 
41 | 		ND_ StringCRef			GetDebugName ()		const
42 | 		{
43 | 			DEBUG_ONLY( return _debugName; )
44 | 			RELEASE_ONLY( return ""; )
45 | 		}
46 | 
47 | 		virtual void SetDebugName (StringCRef name)
48 | 		{
49 | 			DEBUG_ONLY( _debugName = name );
50 | 			GX_UNUSED( name );
51 | 		}
52 | 	};
53 | 
54 | 
55 | 	SHARED_POINTER( BaseObject );
56 | 
57 | 
58 | }	// Base
59 | }	// Engine
60 | 


--------------------------------------------------------------------------------
/Engine/Base/Common/Defines.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | 
 6 | #define CHECK_LINKING( _expr_ ) \
 7 | 	{if ( not (_expr_) ) { \
 8 | 		__GX_CHECK_WARN( (_expr_), GX_TO_ANSI_STRING( _expr_ ), ::GX_STL::ELog::_DefWarning ); \
 9 | 		CHECK( _SetState( EState::LinkingFailed ) ); \
10 | 		return true; \
11 | 	}}
12 | 
13 | #define CHECK_ATTACHMENT( _expr_ ) \
14 | 	{if ( not (_expr_) ) { \
15 | 		__GX_CHECK_WARN( (_expr_), GX_TO_ANSI_STRING( _expr_ ), ::GX_STL::ELog::_DefWarning ); \
16 | 		CHECK( _SetState( EState::IncompleteAttachment ) ); \
17 | 		return true; \
18 | 	}}
19 | 
20 | #define CHECK_COMPOSING( _expr_ ) \
21 | 	{if ( not (_expr_) ) { \
22 | 		__GX_CHECK_WARN( (_expr_), GX_TO_ANSI_STRING( _expr_ ), ::GX_STL::ELog::_DefWarning ); \
23 | 		CHECK( _SetState( EState::ComposingFailed ) ); \
24 | 		return true; \
25 | 	}}
26 | 
27 | 
28 | #if defined(GX_ENABLE_DEBUGGING) or defined(GX_ENABLE_PROFILING)
29 | #	define GX_PROFILE_MSG		ARGS
30 | #else
31 | #	define GX_PROFILE_MSG		__GX_EMPTY_ARGS
32 | #endif
33 | 


--------------------------------------------------------------------------------
/Engine/Base/Common/EModuleGroup.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Common/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Base
10 | {
11 | 
12 | 	namespace EModuleGroup
13 | 	{
14 | 		enum type
15 | 		{
16 | 			// 0 - reserved
17 | 			Global	= 1,
18 | 			Thread,
19 | 			Object,
20 | 			Component,
21 | 
22 | 			// free to use: Object+1 .. _Mask
23 | 
24 | 			_Mask	= CompileTime::_ctime_hidden_::_StringToID_Helper::MASK,
25 | 
26 | 			// max ID's in DECL_STRING_TO_ID
27 | 			_Count	= _Mask + 1,
28 | 		};
29 | 	}
30 | 
31 | 	DECL_STRING_TO_ID( GModID, EModuleGroup::Global );
32 | 	DECL_STRING_TO_ID( TModID, EModuleGroup::Thread );
33 | 	DECL_STRING_TO_ID( OModID, EModuleGroup::Object );
34 | 	DECL_STRING_TO_ID( CModID, EModuleGroup::Component );
35 | 
36 | 
37 | }	// Base
38 | }	// Engine
39 | 
40 | 
41 | namespace GX_STL
42 | {
43 | namespace GXTypes
44 | {
45 | 	
46 | /*
47 | =================================================
48 | 	ToString (GModID)
49 | =================================================
50 | */
51 | 	ND_ inline decltype(auto) ToString (Engine::Base::GModID::type value)
52 | 	{
53 | 		return Engine::Base::GModID::ToString( value );
54 | 	}
55 | 
56 | }	// GXTypes
57 | }	// GX_STL
58 | 
59 | 


--------------------------------------------------------------------------------
/Engine/Base/Common/Enums.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Common/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Base
10 | {
11 | 
12 | 	struct EMemoryAccess
13 | 	{
14 | 		enum type : uint
15 | 		{
16 | 			CpuRead,
17 | 			CpuWrite,
18 | 
19 | 			GpuRead,
20 | 			GpuWrite,
21 | 
22 | 			SequentialOnly,
23 | 
24 | 			_Count,
25 | 			Unknown		= ~0u
26 | 		};
27 | 
28 | 		GX_ENUM_BITFIELD( EMemoryAccess );
29 | 
30 | 		static constexpr bits	CpuReadWrite	= bits().Set( CpuRead ).Set( CpuWrite );
31 | 		static constexpr bits	GpuReadWrite	= bits().Set( GpuRead ).Set( GpuWrite );
32 | 		static constexpr bits	All				= CpuReadWrite | GpuReadWrite;
33 | 
34 | 		static bool HasRandomAccess (bits flags);
35 | 		static bool HasSequentialAccess (bits flags);
36 | 	};
37 | 
38 | 
39 | //-----------------------------------------------------------------------------
40 | // EMemoryAccess
41 | 	
42 | 	inline bool  EMemoryAccess::HasRandomAccess (bits flags)
43 | 	{
44 | 		return not flags[SequentialOnly];
45 | 	}
46 | 
47 | 	inline bool  EMemoryAccess::HasSequentialAccess (bits)
48 | 	{
49 | 		return true;
50 | 	}
51 | 
52 | }	// Base
53 | }	// Engine
54 | 


--------------------------------------------------------------------------------
/Engine/Base/Common/ThreadID.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Common/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Base
10 | {
11 | 
12 | 	//
13 | 	// Thread ID
14 | 	//
15 | 
16 | 	struct ThreadID
17 | 	{
18 | 	// types
19 | 		using Self = ThreadID;
20 | 
21 | 	// varaibles
22 | 	private:
23 | 		usize	_value;
24 | 
25 | 	// method
26 | 	private:
27 | 		explicit
28 | 		ThreadID (usize id) : _value(id)
29 | 		{}
30 | 
31 | 	public:
32 | 		ThreadID (GX_DEFCTOR) : _value(0)
33 | 		{}
34 | 
35 | 		ND_ static ThreadID GetCurrent ()
36 | 		{
37 | 			return ThreadID( OS::CurrentThread::GetCurrentThreadId() );
38 | 		}
39 | 
40 | 		_GX_DIM_CMP_OPERATORS_SELF( _value );
41 | 	};
42 | 
43 | 	
44 | }	// Base
45 | }	// Engine
46 | 


--------------------------------------------------------------------------------
/Engine/Base/DataProvider/DataMessages.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Public/DataProvider.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace DSMsg
10 | {
11 | 
12 | 	//
13 | 	// Open File
14 | 	//
15 | 	struct OpenFileForRead : _MsgBase_
16 | 	{
17 | 	// variables
18 | 		StringCRef					filename;
19 | 		Out< GXFile::RFilePtr >		result;
20 | 
21 | 	// methods
22 | 		explicit OpenFileForRead (StringCRef filename) : filename{filename} {}
23 | 	};
24 | 	
25 | 
26 | 	struct OpenFileForWrite : _MsgBase_
27 | 	{
28 | 	// variables
29 | 		StringCRef					filename;
30 | 		Out< GXFile::WFilePtr >		result;
31 | 
32 | 	// methods
33 | 		explicit OpenFileForWrite (StringCRef filename) : filename{filename} {}
34 | 	};
35 | 
36 | 
37 | }	// DSMsg
38 | }	// Engine
39 | 


--------------------------------------------------------------------------------
/Engine/Base/DataProvider/InMemoryDataProvider.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/Base/DataProvider/InMemoryDataProvider.cpp


--------------------------------------------------------------------------------
/Engine/Base/DataProvider/InternetDataProvider.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/Base/DataProvider/InternetDataProvider.cpp


--------------------------------------------------------------------------------
/Engine/Base/Engine.Base.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | */
 4 | 
 5 | #pragma once
 6 | 
 7 | #include "Engine/Base/Modules/Module.h"
 8 | #include "Engine/Base/Modules/ModulesFactory.h"
 9 | #include "Engine/Base/Modules/ModuleUtils.h"
10 | 
11 | #include "Engine/Base/Public/TaskModule.h"
12 | #include "Engine/Base/Tasks/AsyncTask.h"
13 | 
14 | #include "Engine/Base/Public/ParallelThread.h"
15 | 
16 | #include "Engine/Base/Public/DataProvider.h"
17 | 


--------------------------------------------------------------------------------
/Engine/Base/Modules/Module.Send.inl.h:
--------------------------------------------------------------------------------
 1 | // This is part of 'Module::Send' function.
 2 | {
 3 | 	using FixedMapRange_t	= MixedSizeArray< MessageHandler::Handler, 32 >;
 4 | 	using HandlerSearch		= MessageHandler::HandlerSearch;
 5 | 
 6 | 	FixedMapRange_t	temp;
 7 | 	{
 8 | 		auto&	handlers = _msgHandler._handlers;
 9 | 
10 | 		usize	first;
11 | 		if ( handlers.CustomSearch().FindFirstIndex( HandlerSearch{ var_msg.GetValueTypeId() }, OUT first ) )
12 | 		{
13 | 			for (usize i = first; i < handlers.Count() and handlers[i].first.id == var_msg.GetValueTypeId(); ++i)
14 | 			{
15 | 				/*if ( handlers[i].second.ptr.Lock() == null )
16 | 				{
17 | 					handlers.EraseByIndex( i );
18 | 					--i;
19 | 					continue;
20 | 				}*/
21 | 
22 | 				temp.PushBack( handlers[i].second );
23 | 			}
24 | 		}
25 | 	}
26 | 		
27 | 	for (auto& handler : temp)
28 | 	{
29 | 		handler.func( handler.ptr, handler.data, var_msg );
30 | 	}
31 | 	return not temp.Empty();
32 | }
33 | 


--------------------------------------------------------------------------------
/Engine/Base/Public/CreateInfo.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Modules/MessageHelpers.h"
 6 | #include "Engine/Base/Public/ModuleMessages.h"
 7 | #include "Engine/Base/Common/Enums.h"
 8 | #include "Engine/Base/Common/EngineSubSystems.h"
 9 | 
10 | namespace Engine
11 | {
12 | namespace CreateInfo
13 | {
14 | 	template <typename T>	using ReadOnce	= ModuleMsg::ReadOnce<T>;
15 | 
16 | 	using ModulePtr		= Engine::Base::ModulePtr;
17 | 	using UntypedID_t	= Engine::ModuleMsg::UntypedID_t;
18 | 
19 | 
20 | }	// CreateInfo
21 | }	// Engine
22 | 


--------------------------------------------------------------------------------
/Engine/Base/Public/ProfilingMessages.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Public/ModuleMessages.h"
 6 | #include "Engine/Base/Common/BaseObject.h"
 7 | 
 8 | namespace Engine
 9 | {
10 | namespace ProfilingMsg
11 | {
12 | 	using namespace Engine::_BaseMessages_;
13 | 
14 | 
15 | 	//
16 | 	// On Send Message
17 | 	//
18 | 	struct OnSendMsg : _MsgBase_
19 | 	{
20 | 	// variables
21 | 		ModulePtr							target;
22 | 		WeakPointerType< Base::BaseObject >	sender;
23 | 		VariantCRef							msg;
24 | 
25 | 	// methods
26 | 		template <typename T>
27 | 		OnSendMsg (const ModulePtr &target, const T &msg) :
28 | 			target{target}, sender{msg.Sender()}, msg{ VariantCRef::FromConst(msg) }
29 | 		{}
30 | 	};
31 | 
32 | }	// ProfilingMsg
33 | }	// Engine
34 | 


--------------------------------------------------------------------------------
/Engine/Base/Public/TaskModule.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	TaskModule - attached to thread and process async messages (short time)
 4 | 					and async tasks (long time with progress).
 5 | */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include "Engine/Base/Modules/Module.h"
10 | 
11 | namespace Engine
12 | {
13 | namespace CreateInfo
14 | {
15 | 
16 | 	//
17 | 	// Task Module Create Info
18 | 	//
19 | 	struct TaskModule
20 | 	{
21 | 		// TODO: set priority or something else
22 | 		ModulePtr		manager;
23 | 	};
24 | 	
25 | 
26 | 	//
27 | 	// Task Manager Create Info
28 | 	//
29 | 	struct TaskManager
30 | 	{
31 | 	};
32 | 
33 | }	// CreateInfo
34 | }	// Engine
35 | 


--------------------------------------------------------------------------------
/Engine/Graphics/Engine.Graphics.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	High level graphics interface.
 4 | 	2D:
 5 | 		- Batching
 6 | 		- Font
 7 | 	3D:
 8 | 		...
 9 | 	Procedural generation:
10 | 		...
11 | */
12 | 
13 | #pragma once
14 | 
15 | 
16 | // Batch Renderer
17 | #include "Engine/Graphics/Public/BatchRenderer.h"
18 | #include "Engine/Graphics/Public/Vertices.h"
19 | #include "Engine/Graphics/Public/Primitives.h"
20 | 
21 | // Font
22 | #include "Engine/Graphics/Public/Font.h"
23 | 
24 | // Helpers
25 | #include "Engine/Graphics/Public/Commands.h"
26 | 
27 | // Procedural
28 | 
29 | 


--------------------------------------------------------------------------------
/Engine/Graphics/Impl/GraphicsBaseModule.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Graphics/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Graphics
10 | {
11 | 
12 | 	//
13 | 	// Graphics Base Module
14 | 	//
15 | 
16 | 	class GraphicsBaseModule : public Module
17 | 	{
18 | 	// types
19 | 	protected:
20 | 		using SupportedEvents_t		= MessageListFrom<
21 | 											ModuleMsg::Compose,
22 | 											ModuleMsg::Delete,
23 | 											GpuMsg::DeviceBeforeDestroy
24 | 										>;
25 | 
26 | 	// methods
27 | 	public:
28 | 		GraphicsBaseModule (const GlobalSystemsRef gs,
29 | 							const ModuleConfig &config,
30 | 							const TypeIdList *eventTypes);
31 | 
32 | 	// message handlers
33 | 	protected:
34 | 		bool _OnManagerChanged (const ModuleMsg::OnManagerChanged &);
35 | 		bool _DeviceBeforeDestroy (const GpuMsg::DeviceBeforeDestroy &);
36 | 		
37 | 	protected:
38 | 		ND_ ModulePtr  _GetGpuThread (const ModulePtr &gpuThread = null) const;
39 | 	};
40 | 
41 | 
42 | }	// Graphics
43 | }	// Engine
44 | 


--------------------------------------------------------------------------------
/Engine/Graphics/Public/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Engine.Platforms.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Graphics
10 | {
11 | 	using namespace Engine::Base;
12 | 	using namespace GX_STL::GXMath;
13 | 	using EPrimitive		= Engine::Platforms::EPrimitive;
14 | 	using VertexInputState	= Engine::Platforms::VertexInputState;
15 | 	
16 | 
17 | 	void RegisterGraphics ();
18 | 	void UnregisterGraphics ();
19 | 
20 | }	// Graphics
21 | 
22 | namespace GraphicsMsg
23 | {
24 | 	using namespace Engine::_BaseMessages_;
25 | 
26 | }	// GraphicsMsg
27 | }	// Engine
28 | 


--------------------------------------------------------------------------------
/Engine/Graphics/Public/Font.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Graphics/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Graphics
10 | {
11 | 
12 | }	// Graphics
13 | 
14 | namespace CreateInfo
15 | {
16 | 
17 | 	//
18 | 	// Font
19 | 	//
20 | 	struct Font
21 | 	{
22 | 		ModulePtr	gpuThread;
23 | 	};
24 | 
25 | 
26 | 	//
27 | 	// Font Manager
28 | 	//
29 | 	struct FontManager
30 | 	{
31 | 		ModulePtr	gpuThread;
32 | 	};
33 | 
34 | }	// CreateInfo
35 | 
36 | namespace FontMsg
37 | {
38 | 	
39 | 
40 | }	// FontMsg
41 | }	// Engine
42 | 


--------------------------------------------------------------------------------
/Engine/Graphics/Public/IDs.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Graphics/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Graphics
10 | {
11 | 
12 | 	// Font
13 | 	static constexpr OModID::type  FontModuleID					= "font"_OModID;
14 | 	static constexpr OModID::type  FontManagerModuleID			= "font-mngr"_OModID;
15 | 
16 | 	// Batch
17 | 	static constexpr OModID::type  BatchRendererModuleID		= "batch-ren"_OModID;
18 | 	
19 | 	// Command buffer
20 | 	static constexpr OModID::type  CommandBufferManagerModuleID	= "pf-cmdbuf"_OModID;
21 | 	static constexpr OModID::type  AsyncCommandBufferModuleID	= "asc-cmdbuf"_OModID;
22 | 
23 | 	// Memory Stream
24 | 	static constexpr OModID::type  MemoryInputStreamModuleID	= "mem.istream"_OModID;
25 | 	static constexpr OModID::type  MemoryOutputStreamModuleID	= "mem.ostream"_OModID;
26 | 
27 | }	// Graphics
28 | }	// Engine
29 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Engine.ImportExport.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	Project with import/export modules without third-party dependencies.
 4 | */
 5 | 
 6 | #pragma once
 7 | 
 8 | 
 9 | #include "Engine/ImportExport/Public/Image.h"
10 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Impl/GX_ImageSaver.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/ImportExport/Impl/GX_ImageSaver.cpp


--------------------------------------------------------------------------------
/Engine/ImportExport/Impl/ImportExportObjectsConstructor.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ImportExport/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace CreateInfo
10 | {
11 | 
12 | 	struct ImageLoader;
13 | 	struct ImageSaver;
14 | 
15 | }	// CreateInfo
16 | 
17 | 
18 | namespace ImportExport
19 | {
20 | 	
21 | 	//
22 | 	// Import-Export Objects Constructor
23 | 	//
24 | 
25 | 	class ImportExportObjectsConstructor final : public Noninstancable
26 | 	{
27 | 	public:
28 | 		static ModulePtr CreateGXImageLoader (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::ImageLoader &);
29 | 		static ModulePtr CreateGXImageSaver (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::ImageSaver &);
30 | 	};
31 | 
32 | 
33 | }	// ImportExport
34 | }	// Engine
35 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Impl/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Engine/ImportExport/Impl/ImportExportObjectsConstructor.h"
 4 | #include "Engine/ImportExport/Public/Image.h"
 5 | 
 6 | namespace Engine
 7 | {
 8 | namespace ImportExport
 9 | {
10 | 
11 | /*
12 | =================================================
13 | 	RegisterImportExport
14 | =================================================
15 | */
16 | 	void RegisterImportExport ()
17 | 	{
18 | 		using IEOC = ImportExportObjectsConstructor;
19 | 
20 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
21 | 
22 | 		CHECK( mf->Register( GXImageLoaderModuleID, &IEOC::CreateGXImageLoader ) );
23 | 		//CHECK( mf->Register( GXImageSaverModuleID, &IEOC::CreateGXImageSaver ) );
24 | 	}
25 | 	
26 | /*
27 | =================================================
28 | 	UnregisterImportExport
29 | =================================================
30 | */
31 | 	void UnregisterImportExport ()
32 | 	{
33 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
34 | 		
35 | 		mf->UnregisterAll( GXImageLoaderModuleID );
36 | 		mf->UnregisterAll( GXImageSaverModuleID );
37 | 	}
38 | 
39 | }	// ImportExport
40 | }	// Engine
41 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Public/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Graphics/Engine.Graphics.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace ImportExport
10 | {
11 | 	using namespace Engine::Base;
12 | 
13 | 
14 | 	void RegisterImportExport ();
15 | 	void UnregisterImportExport ();
16 | 
17 | }	// ImportExport
18 | }	// Engine
19 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Public/IDs.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ImportExport/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace ImportExport
10 | {
11 | 
12 | 	// Image Loaders & Savers
13 | 	static constexpr OModID::type  GXImageLoaderModuleID			= "gx.iload"_OModID;
14 | 	static constexpr OModID::type  GXImageSaverModuleID				= "gx.isave"_OModID;
15 | 
16 | 	// Mesh Loaders & Savers
17 | 	static constexpr OModID::type  GXMeshLoaderModuleID				= "gx.mload"_OModID;
18 | 	static constexpr OModID::type  GXMeshSaverModuleID				= "gx.msave"_OModID;
19 | 
20 | 
21 | }	// ImportExport
22 | }	// Engine
23 | 


--------------------------------------------------------------------------------
/Engine/ImportExport/Public/Image.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ImportExport/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace CreateInfo
10 | {
11 | 
12 | 	//
13 | 	// Image Loader Create Info
14 | 	//
15 | 	struct ImageLoader
16 | 	{
17 | 	// types
18 | 		using EImageLayout	= Platforms::EImageLayout;
19 | 
20 | 	// variables
21 | 		ModulePtr			dataInput;		// random access data input module
22 | 		EImageLayout::type	imageLayout;	// image layout after loading
23 | 
24 | 	// methods
25 | 		explicit ImageLoader (const ModulePtr &dataInput, EImageLayout::type layout = EImageLayout::ShaderReadOnlyOptimal) : dataInput{dataInput}, imageLayout{layout} {}
26 | 	};
27 | 
28 | 
29 | 	//
30 | 	// Image Saver Create Info
31 | 	//
32 | 	struct ImageSaver
33 | 	{
34 | 	// types
35 | 		using EImageLayout	= Platforms::EImageLayout;
36 | 
37 | 	// variables
38 | 		ModulePtr			asyncThread;	// can be null, used to asynchroniusly save image
39 | 		ModulePtr			dataOutput;		// random access data output module
40 | 		EImageLayout::type	imageLayout;	// image layout after saving
41 | 
42 | 	// methods
43 | 		ImageSaver (const ModulePtr &dataOutput, EImageLayout::type layout, const ModulePtr &asyncThread = null) :
44 | 			asyncThread{asyncThread}, dataOutput{dataOutput}, imageLayout{layout} {}
45 | 	};
46 | 
47 | }	// CreateInfo
48 | }	// Engine


--------------------------------------------------------------------------------
/Engine/ImportExport/README.md:
--------------------------------------------------------------------------------
 1 | # Import-Export Modules
 2 | 
 3 | Supported loaders:
 4 | - GXImage (WIP)
 5 | - GXMesh (WIP)
 6 | 
 7 | Supported savers:
 8 | - GXImage (WIP)
 9 | - GXMesh (WIP)
10 |  
11 |  
12 | ## GXImage format
13 | Header
14 | ```cpp
15 | [ 0] ulong	version;	// file type and version (magic number)
16 | [ 8] uint	width;		// in pixels
17 | [12] uint	height;		// in pixels
18 | [16] uint	depth;		// in pixels
19 | [20] uint	layers;
20 | [24] uint	maxLevels;
21 | [28] uint	samples;
22 | [32] uint	flags;		// CubeMap, ...
23 | [36] uint	pixelFormat;
24 | [40] uint	blockSize;	// in bytes		// can be used for streaming, may be (max_row_pitch * N)
25 | [44] uint	levelsSize;	// in bytes		// 
26 | [48] -----------
27 | 
28 | // 1D, 2D, 3D mipmap level
29 | struct Level
30 | {
31 | 	uint	memOffset;		// in bytes		// pixels = memOffset + baseOffset
32 | 	uint3	dimension;		// in pixels
33 | 	uint	layer;
34 | 	uint	level;
35 | 	uint	rowPitch;		// in bytes		// for 2D, 3D
36 | 	uint	slicePitch;		// in bytes		// for 3D
37 | };
38 | 
39 | [48] Mipmaps	levels[header.layers * header.maxLevels];
40 | ```
41 | 
42 | Data can be placed separately from header.
43 |  
44 |  
45 | ## GXMesh format
46 | TODO
47 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/Common/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/GPU/ShaderEnums.h"
 6 | #include "Engine/Platforms/Public/GPU/PixelFormatEnums.h"
 7 | #include "Engine/Platforms/Public/GPU/ImageEnums.h"
 8 | #include "Engine/Platforms/Public/GPU/SamplerEnums.h"
 9 | #include "Engine/Platforms/Public/GPU/RenderState.h"
10 | #include "Engine/Platforms/Public/GPU/Pipeline.h"
11 | #include "Engine/Platforms/Public/GPU/Sampler.h"
12 | #include "Engine/Platforms/Public/GPU/VertexAttribs.h"
13 | 
14 | namespace PipelineCompiler
15 | {
16 | 	using namespace GX_STL;
17 | 	using namespace GX_STL::GXTypes;
18 | 	using namespace GX_STL::GXMath;
19 | 
20 | 	using namespace Engine;
21 | 	using namespace Engine::Base;
22 | 	using namespace Engine::Platforms;
23 | 
24 | }	// PipelineCompiler
25 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/Pipelines/ComputePipeline.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/PipelineCompiler/Pipelines/BasePipeline.h"
 6 | 
 7 | namespace PipelineCompiler
 8 | {
 9 | 
10 | 	//
11 | 	// Compute Pipeline
12 | 	//
13 | 
14 | 	class ComputePipeline : public BasePipeline
15 | 	{
16 | 	// variables
17 | 	protected:
18 | 		ShaderModule	shader		{ EShader::Compute };
19 | 
20 | 
21 | 	// methods
22 | 	protected:
23 | 		explicit ComputePipeline (StringCRef name);
24 | 		
25 | 	private:
26 | 		bool Prepare (const ConverterConfig &cfg) override final;
27 | 		bool Convert (OUT String &src, Ptr<ISerializer> ser, const ConverterConfig &cfg) const override final;
28 | 		
29 | 		bool _ConvertComputeShader (INOUT String &src, Ptr<ISerializer> ser, const ConverterConfig &cfg) const;
30 | 	};
31 | 
32 | }	// PipelineCompiler
33 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/cl/cl_source_vfs.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "cl_source_vfs.h"
 4 | #include "Core/STL/Containers/HashMap.h"
 5 | 
 6 | namespace cl_vfs
 7 | {
 8 | 	extern void VFS_funcs (OUT String &src);
 9 | 	extern void VFS_matrix (OUT String &src);
10 | 	extern void VFS_vload (OUT String &src);
11 | 
12 | 	bool LoadFile (StringCRef filename, OUT String &src)
13 | 	{
14 | 		static const HashMap< String, void (*) (OUT String &) > vfs = {
15 | 			{ "funcs.cl", &VFS_funcs },
16 | 			{ "matrix.cl", &VFS_matrix },
17 | 			{ "vload.cl", &VFS_vload }
18 | 		};
19 | 
20 | 		usize idx = UMax;
21 | 		if ( vfs.FindIndex( filename, OUT idx ) ) {
22 | 			vfs[idx].second( OUT src );
23 | 			return true;
24 | 		}
25 | 		return false;
26 | 	}
27 | }	// cl_vfs
28 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/cl/cl_source_vfs.h:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "Core/STL/Containers/String.h"
 4 | #include "Core/STL/Math/BinaryMath.h"
 5 | 
 6 | namespace cl_vfs
 7 | {
 8 | 
 9 | 	using namespace GX_STL;
10 | 	using namespace GX_STL::GXTypes;
11 | 
12 | 	bool LoadFile (StringCRef filename, OUT String &src);
13 | 
14 | }	// cl_vfs
15 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/glsl/Blur.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "glsl_source_vfs.h"
 4 | 
 5 | namespace glsl_vfs
 6 | {
 7 | 	extern void VFS_Effects_Blur (OUT String &src)
 8 | 	{
 9 | 		src << R"#(/*
10 | 	Blur postprocess
11 | */
12 | 
13 | float4 SimpleBlur (sampler2D tex, float2 uv, int radius, float uvScale);
14 | 
15 | 
16 | //-----------------------------------------------------------------------------
17 | 
18 | 
19 | #include <Math/Math.glsl>
20 | 
21 | /*
22 | =================================================
23 | 	SimpleBlur
24 | =================================================
25 | */
26 | float4 SimpleBlur (sampler2D tex, float2 uv, int radius, float uvScale)
27 | {
28 | 	float	kernel	 = 0.0;
29 | 	float4	color	 = float4(0.0);
30 | 	float2	uv_scale = uvScale / float2(textureSize( tex, 0 ).xy);
31 | 
32 | 	for (int y = -radius; y <= radius; ++y)
33 | 	{
34 | 		for (int x = -radius; x <= radius; ++x)
35 | 		{
36 | 			float2	c = float2(x, y);
37 | 			float	k = 1.0 / Pow( 2.0, Abs(c.x) + Abs(c.y) );
38 | 
39 | 			color  += texture( tex, uv + c * uv_scale ) * k;
40 | 			kernel += k;
41 | 		}
42 | 	}
43 | 	return color / kernel;
44 | }
45 | )#";
46 | 
47 | 	}
48 | }	// glsl_vfs
49 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/glsl/Matrix.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "glsl_source_vfs.h"
 4 | 
 5 | namespace glsl_vfs
 6 | {
 7 | 	extern void VFS_Math_Matrix (OUT String &src)
 8 | 	{
 9 | 		src << R"#(/*
10 | 	Matrix functions.
11 | 	
12 | 	license: free
13 | */
14 | 
15 | 
16 | 
17 | //-----------------------------------------------------------------------------
18 | 
19 | )#";
20 | 
21 | 	}
22 | }	// glsl_vfs
23 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/glsl/Voronoi.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "glsl_source_vfs.h"
 4 | 
 5 | namespace glsl_vfs
 6 | {
 7 | 	extern void VFS_Noise_Voronoi (OUT String &src)
 8 | 	{
 9 | 		src << R"#(
10 | 
11 | 
12 | 
13 | //-----------------------------------------------------------------------------
14 | 
15 | 
16 | // TODO
17 | //	https://www.shadertoy.com/view/Xll3zX
18 | //	https://www.shadertoy.com/view/4sK3WK
19 | 
20 | )#";
21 | 
22 | 	}
23 | }	// glsl_vfs
24 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/glsl/glsl_source_vfs.h:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "Core/STL/Containers/String.h"
 4 | #include "Core/STL/Math/BinaryMath.h"
 5 | 
 6 | namespace glsl_vfs
 7 | {
 8 | 
 9 | 	using namespace GX_STL;
10 | 	using namespace GX_STL::GXTypes;
11 | 
12 | 	bool LoadFile (StringCRef filename, OUT String &src);
13 | 
14 | }	// glsl_vfs
15 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/hlsl/hlsl_source_vfs.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "hlsl_source_vfs.h"
 4 | #include "Core/STL/Containers/HashMap.h"
 5 | 
 6 | namespace hlsl_vfs
 7 | {
 8 | 	extern void VFS_vload (OUT String &src);
 9 | 
10 | 	bool LoadFile (StringCRef filename, OUT String &src)
11 | 	{
12 | 		static const HashMap< String, void (*) (OUT String &) > vfs = {
13 | 			{ "vload.hl", &VFS_vload }
14 | 		};
15 | 
16 | 		usize idx = UMax;
17 | 		if ( vfs.FindIndex( filename, OUT idx ) ) {
18 | 			vfs[idx].second( OUT src );
19 | 			return true;
20 | 		}
21 | 		return false;
22 | 	}
23 | }	// hlsl_vfs
24 | 


--------------------------------------------------------------------------------
/Engine/PipelineCompiler/hlsl/hlsl_source_vfs.h:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "Core/STL/Containers/String.h"
 4 | #include "Core/STL/Math/BinaryMath.h"
 5 | 
 6 | namespace hlsl_vfs
 7 | {
 8 | 
 9 | 	using namespace GX_STL;
10 | 	using namespace GX_STL::GXTypes;
11 | 
12 | 	bool LoadFile (StringCRef filename, OUT String &src);
13 | 
14 | }	// hlsl_vfs
15 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Engine.Platforms.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	Abstraction level for OS, Graphics API, Compute API and other.
 4 | */
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "Engine/Platforms/Public/GPU/Context.h"
 9 | #include "Engine/Platforms/Public/GPU/Thread.h"
10 | 
11 | #include "Engine/Platforms/Public/GPU/Buffer.h"
12 | #include "Engine/Platforms/Public/GPU/CommandBuffer.h"
13 | #include "Engine/Platforms/Public/GPU/Framebuffer.h"
14 | #include "Engine/Platforms/Public/GPU/Memory.h"
15 | #include "Engine/Platforms/Public/GPU/Pipeline.h"
16 | #include "Engine/Platforms/Public/GPU/RenderPass.h"
17 | #include "Engine/Platforms/Public/GPU/Sampler.h"
18 | #include "Engine/Platforms/Public/GPU/Image.h"
19 | #include "Engine/Platforms/Public/GPU/Query.h"
20 | #include "Engine/Platforms/Public/GPU/VR.h"
21 | 
22 | #include "Engine/Platforms/Public/OS/Platform.h"
23 | #include "Engine/Platforms/Public/OS/Window.h"
24 | #include "Engine/Platforms/Public/OS/Input.h"
25 | 
26 | //#include "Engien/Platforms/DirectX/Impl/DX11Messages.h"
27 | //#include "Engine/Platforms/Vulkan/110/Vk1Messages.h"
28 | //#include "Engine/Platforms/OpenGL/450/GL4Messages.h"
29 | //#include "Engine/Platforms/OpenCL/120/CL1Messages.h"
30 | //#include "Engine/Platforms/Soft/Impl/SWMessages.h"
31 | //#include "Engine/Platforms/Windows/WinMessages.h"
32 | //#include "Engine/Platforms/SDL/SDLMessages.h"
33 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Input/InputManager.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/OS/Input.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Platforms
10 | {
11 | 
12 | 	//
13 | 	// Input Manger
14 | 	//
15 | 
16 | 	class InputManager final : public Module
17 | 	{
18 | 	// types
19 | 	private:
20 | 		using SupportedEvents_t		= Module::SupportedEvents_t;
21 | 
22 | 		using InputThreads_t		= Set< ModulePtr >;
23 | 
24 | 
25 | 	// constants
26 | 	private:
27 | 		static const TypeIdList		_eventTypes;
28 | 
29 | 		
30 | 	// variables
31 | 	private:
32 | 		InputThreads_t		_threads;
33 | 		
34 | 
35 | 	// methods
36 | 	public:
37 | 		InputManager (UntypedID_t, GlobalSystemsRef gs, const CreateInfo::InputManager &ci);
38 | 		~InputManager ();
39 | 		
40 | 		static void Register ();
41 | 		static void Unregister ();
42 | 
43 | 		
44 | 	// message handlers
45 | 	private:
46 | 		bool _AddToManager (const ModuleMsg::AddToManager &);
47 | 		bool _RemoveFromManager (const ModuleMsg::RemoveFromManager &);
48 | 		
49 | 	private:
50 | 		static ModulePtr _CreateInputThread (UntypedID_t, GlobalSystemsRef, const CreateInfo::InputThread &);
51 | 		static ModulePtr _CreateInputManager (UntypedID_t, GlobalSystemsRef, const CreateInfo::InputManager &);
52 | 	};
53 | 
54 | 
55 | }	// Platforms
56 | }	// Engine
57 | 


--------------------------------------------------------------------------------
/Engine/Platforms/OpenGL/EGL/EGLRenderContext.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/Platforms/OpenGL/EGL/EGLRenderContext.cpp


--------------------------------------------------------------------------------
/Engine/Platforms/OpenGL/EGL/EGLRenderContext.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 


--------------------------------------------------------------------------------
/Engine/Platforms/OpenGL/Linux/GLX11Library.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | #include "Core/Config/Engine.Config.h"
 7 | 
 8 | #if defined( GRAPHICS_API_OPENGL ) and defined( PLATFORM_LINUX )
 9 | 
10 | #include "Engine/Platforms/Public/Common.h"
11 | 
12 | namespace Engine
13 | {
14 | namespace PlatformGL
15 | {
16 | 	
17 | 	//
18 | 	// Linux OpenGL Library
19 | 	//
20 | 
21 | 	struct GLX11Library
22 | 	{
23 | 	// types
24 | 	private:
25 | 		using FuncPtr_t	= DeferredTypeFrom<void*>;
26 | 
27 | 
28 | 	// variables
29 | 	private:
30 | 		OS::Library		_lib;
31 | 		FuncPtr_t		_getProc;
32 | 		FuncPtr_t		_getProcARB;
33 | 
34 | 
35 | 	// methods
36 | 	public:
37 | 		GLX11Library ();
38 | 
39 | 		bool Load (StringCRef name = StringCRef());
40 | 
41 | 		void Unload ();
42 | 
43 | 		SharedLibFunction_t  GetProc (StringCRef address) const;
44 | 
45 | 		static StringCRef  GetDefaultName ();
46 | 
47 | 	private:
48 | 		bool _OnInit ();
49 | 	};
50 | 
51 | 
52 | 	using GLLibrary		= GLX11Library;
53 | 
54 | 
55 | }	// PlatformGL
56 | }	// Engine
57 | 
58 | #endif	// GRAPHICS_API_OPENGL and PLATFORM_LINUX
59 | 


--------------------------------------------------------------------------------
/Engine/Platforms/OpenGL/Windows/GLWinLibrary.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | #include "Core/Config/Engine.Config.h"
 7 | 
 8 | #if defined( GRAPHICS_API_OPENGL ) and defined( PLATFORM_WINDOWS )
 9 | 
10 | #include "Engine/Platforms/Public/Common.h"
11 | 
12 | namespace Engine
13 | {
14 | namespace PlatformGL
15 | {
16 | 	
17 | 	//
18 | 	// Windows OpenGL Library
19 | 	//
20 | 
21 | 	struct GLWinLibrary
22 | 	{
23 | 	// types
24 | 	private:
25 | 		using FuncPtr_t	= DeferredTypeFrom<void*>;
26 | 
27 | 
28 | 	// variables
29 | 	private:
30 | 		OS::Library		_lib;
31 | 		FuncPtr_t		_getProc;	// wglGetProcAddress*
32 | 
33 | 
34 | 	// methods
35 | 	public:
36 | 		GLWinLibrary ();
37 | 
38 | 		bool Load (StringCRef name = StringCRef());
39 | 
40 | 		void Unload ();
41 | 
42 | 		SharedLibFunction_t  GetProc (StringCRef address) const;
43 | 
44 | 		static StringCRef  GetDefaultName ();
45 | 
46 | 	private:
47 | 		bool _OnInit ();
48 | 	};
49 | 
50 | 
51 | 	using GLLibrary		= GLWinLibrary;
52 | 
53 | 
54 | }	// PlatformGL
55 | }	// Engine
56 | 
57 | #endif	// GRAPHICS_API_OPENGL and PLATFORM_WINDOWS
58 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Engine.Base.h"
 6 | 
 7 | #include "Core/STL/Math/Mathematics.h"
 8 | #include "Core/STL/Math/Vec.h"
 9 | #include "Core/STL/Math/Matrix.h"
10 | #include "Core/STL/Math/2D/Rectangle.h"
11 | #include "Core/STL/Math/Color/Color.h"
12 | #include "Core/STL/Math/MathTypeCast.h"
13 | 
14 | namespace Engine
15 | {
16 | namespace Platforms
17 | {
18 | 	using namespace Engine::Base;
19 | 	using namespace GX_STL::GXMath;
20 | 	
21 | 	void RegisterPlatforms ();
22 | 	void UnregisterPlatforms ();
23 | 
24 | }	// Platforms
25 | 
26 | namespace GpuMsg {
27 | 	using namespace Engine::_BaseMessages_;
28 | }
29 | 
30 | namespace OSMsg {
31 | 	using namespace Engine::_BaseMessages_;
32 | }
33 | 
34 | namespace CreateInfo
35 | {}
36 | 
37 | }	// Engine
38 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/GPU/ImageLayer.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Platforms
10 | {
11 | 
12 | 	//
13 | 	// Image Array Layer
14 | 	//
15 | 	
16 | 	struct ImageLayer final : CompileTime::PODStruct
17 | 	{
18 | 	// types
19 | 	private:
20 | 		using Self	= ImageLayer;
21 | 
22 | 
23 | 	// variables
24 | 	private:
25 | 		uint		_value;
26 | 
27 | 
28 | 	// methods
29 | 	public:
30 | 		constexpr ImageLayer (GX_DEFCTOR) : _value(UMax) {}
31 | 
32 | 		explicit constexpr ImageLayer (uint value) : _value(value) {}
33 | 
34 | 		ND_ constexpr bool IsDefined ()	const	{ return _value != UMax; }
35 | 
36 | 		ND_ constexpr uint Get ()		const	{ return IsDefined() ? _value : 0; }
37 | 
38 | 		_GX_DIM_CMP_OPERATORS_SELF( _value )
39 | 	};
40 | 	
41 | 
42 | 	ND_ inline constexpr ImageLayer operator "" _layer (unsigned long long value)		{ return ImageLayer( uint(value) ); }
43 | 
44 | 
45 | }	// Platforms
46 | }	// Engine
47 | 
48 | namespace GX_STL
49 | {
50 | namespace GXTypes
51 | {
52 | 	template <>
53 | 	struct Hash< Engine::Platforms::ImageLayer >
54 | 	{
55 | 		ND_ HashResult  operator () (const Engine::Platforms::ImageLayer &value) const
56 | 		{
57 | 			return HashOf( value.Get() );
58 | 		}
59 | 	};
60 | 
61 | }	// GXTypes
62 | }	// GX_STL
63 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/GPU/MemoryEnums.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Platforms
10 | {
11 | 	
12 | 	struct EGpuMemory
13 | 	{
14 | 		enum type : uint
15 | 		{
16 | 			LocalInGPU,
17 | 			CoherentWithCPU,
18 | 			CachedInCPU,
19 | 			//LazilyAllocated,
20 | 			Dedicated,			// indicates that buffer/image have exlusive memory object
21 | 			SupportAliasing,	// memory object may be binded to many buffers/images
22 | 
23 | 			_Count,
24 | 			Unknown = ~0u
25 | 		};
26 | 
27 | 		GX_ENUM_BITFIELD( EGpuMemory );
28 | 	};
29 | 
30 | }	// Platforms
31 | }	// Engine
32 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/GPU/MultiSamples.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | #include "Core/STL/Dimensions/PowerOfTwoValue.h"
 7 | 
 8 | namespace Engine
 9 | {
10 | namespace Platforms
11 | {
12 | 
13 | 	//
14 | 	// Multi Samples
15 | 	//
16 | 	
17 | 	struct MultiSamples final : CompileTime::PODStruct
18 | 	{
19 | 	// types
20 | 	private:
21 | 		using Self	= MultiSamples;
22 | 
23 | 
24 | 	// variables
25 | 	private:
26 | 		PowOf2Value<uint>	_value;
27 | 
28 | 
29 | 	// methods
30 | 	public:
31 | 		constexpr MultiSamples (GX_DEFCTOR) : _value(0) {}
32 | 
33 | 		explicit constexpr MultiSamples (PowOf2Value<uint> samples) : _value(samples) {}
34 | 
35 | 		explicit constexpr MultiSamples (uint samples) : _value( PowOf2Value<uint>::From(samples) ) {}
36 | 
37 | 		ND_ constexpr uint Get ()			const		{ return _value.GetValue(); }
38 | 		ND_ constexpr uint GetPowerOf2 ()	const		{ return _value.GetPower(); }
39 | 
40 | 		ND_ constexpr bool IsEnabled ()		const		{ return _value.GetPower() > 0; }
41 | 
42 | 		_GX_DIM_CMP_OPERATORS_SELF( _value )
43 | 	};
44 | 	
45 | 
46 | 	ND_ inline constexpr MultiSamples operator "" _samples (unsigned long long value)	{ return MultiSamples( uint(value) ); }
47 | 
48 | 
49 | }	// Platforms
50 | }	// Engine
51 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/GPU/ObjectEnums.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Platforms
10 | {
11 | 
12 | 	struct EGpuObject
13 | 	{
14 | 		enum type : uint
15 | 		{
16 | 			Instance,
17 | 			PhysicalDevice,
18 | 			Device,
19 | 			Queue,
20 | 			Semaphore,
21 | 			CommandBuffer,
22 | 			Fence,
23 | 			DeviceMemory,
24 | 			Buffer,
25 | 			Image,
26 | 			Event,
27 | 			QueryPool,
28 | 			BufferView,
29 | 			ImageView,
30 | 			ShaderModule,
31 | 			PipelineCache,
32 | 			PipelineLayout,
33 | 			RenderPass,
34 | 			Pipeline,
35 | 			Sampler,
36 | 			DescriptorSetLayout,
37 | 			DescriptorPool,
38 | 			DescriptorSet,
39 | 			Framebuffer,
40 | 			CommandPool,
41 | 			Surface,
42 | 			Swapchain,
43 | 			//DebugReport,
44 | 			Display,
45 | 			//DisplayMode,
46 | 			VertexArray,		// OpenGL only
47 | 			Query,				// OpenGL only
48 | 
49 | 			Unknown		= ~0u
50 | 		};
51 | 	};
52 | 
53 | }	// Platforms
54 | }	// Engine
55 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/GPU/QueryEnums.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Platforms
10 | {
11 | 
12 | 	struct EQuery
13 | 	{
14 | 		enum type : uint
15 | 		{
16 | 			Unknown	= 0,
17 | 			Occlusion,
18 | 			PipelineStatistic,
19 | 			Timestamp,
20 | 		};
21 | 	};
22 | 
23 | 
24 | 	struct EPipelineStatistic
25 | 	{
26 | 		enum type : uint
27 | 		{
28 | 			InputAssemblyVertices,
29 | 			TessellationControllShaderPatches,
30 | 
31 | 			// primitives
32 | 			InputAssembluPrimitives,
33 | 			GeometryShaderPrimitives,
34 | 			ClippingPrimitives,
35 | 			
36 | 			// invocations
37 | 			VertexShaderInvocations,
38 | 			GeometryShaderInvocations,
39 | 			ClippingInvocations,
40 | 			FragmentShaderInvocations,
41 | 			TessellationEvaluationShaderInvocations,
42 | 			ComputeShaderInvocations,
43 | 
44 | 			_Count
45 | 		};
46 | 
47 | 		GX_ENUM_BITFIELD( EPipelineStatistic );
48 | 	};
49 | 
50 | }	// Platforms
51 | }	// Engine
52 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/Tools/GPUThreadHelper.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/GPU/Thread.h"
 6 | #include "Engine/Platforms/Public/GPU/VR.h"
 7 | 
 8 | namespace Engine
 9 | {
10 | namespace PlatformTools
11 | {
12 | 	using namespace Engine::Platforms;
13 | 
14 | 
15 | 	//
16 | 	// GPU Thread Helper
17 | 	//
18 | 
19 | 	class GPUThreadHelper final : public Noninstancable
20 | 	{
21 | 	// methods
22 | 	public:
23 | 		ND_ static ModulePtr  FindGraphicsThread (GlobalSystemsRef gs);
24 | 		ND_ static ModulePtr  FindComputeThread (GlobalSystemsRef gs);
25 | 		ND_ static ModulePtr  FindVRThread (GlobalSystemsRef gs);		// graphics + VR
26 | 	};
27 | 
28 | 
29 | }	// PlatformTools
30 | }	// Engine
31 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Public/Tools/SamplerUtils.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/GPU/Sampler.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace PlatformTools
10 | {
11 | 	using namespace Engine::Platforms;
12 | 
13 | 
14 | 	//
15 | 	// Sampler Utils
16 | 	//
17 | 
18 | 	struct SamplerUtils final : public Noninstancable
19 | 	{
20 | 		static void ValidateDescription (INOUT SamplerDescription &descr, uint maxAnisotropyLevel);
21 | 	};
22 | 
23 | }	// PlatformTools
24 | }	// Engine
25 | 


--------------------------------------------------------------------------------
/Engine/Platforms/SDL/SDLDisplay.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | #include "Engine/Platforms/Public/OS/Display.h"
10 | #include "Engine/Platforms/Public/OS/Platform.h"
11 | 
12 | namespace Engine
13 | {
14 | namespace PlatformSDL
15 | {
16 | 	using namespace Engine::Platforms;
17 | 
18 | 
19 | 	//
20 | 	// SDL Display Helper
21 | 	//
22 | 
23 | 	struct SDLDisplay final
24 | 	{
25 | 	// types
26 | 	private:
27 | 		using Displays_t	= OSMsg::GetDisplays::Displays_t;
28 | 
29 | 
30 | 	// variables
31 | 	private:
32 | 		Displays_t		_displays;
33 | 
34 | 
35 | 	// methods
36 | 	public:
37 | 		SDLDisplay ();
38 | 
39 | 		bool Update ();
40 | 
41 | 		ArrayCRef<Display> GetDisplays () const		{ return _displays; }
42 | 	};
43 | 
44 | 
45 | }	// PlatformSDL
46 | }	// Engine
47 | 
48 | #endif	// PLATFORM_SDL
49 | 


--------------------------------------------------------------------------------
/Engine/Platforms/SDL/SDLMessages.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | #include "Engine/Platforms/Public/OS/Display.h"
10 | #include "Engine/Platforms/Public/OS/Window.h"
11 | #include "Engine/Platforms/Public/OS/Platform.h"
12 | 
13 | namespace Engine
14 | {
15 | namespace OSMsg
16 | {
17 | 
18 | 	//
19 | 	// Request Window Handle
20 | 	//
21 | 	struct GetSDLWindowHandle : _MsgBase_
22 | 	{
23 | 		Out< SDL_Window *>	result;
24 | 	};
25 | 
26 | 
27 | 	//
28 | 	// Window Raw Message from OS
29 | 	//
30 | 	struct OnSDLWindowRawMessage : _MsgBase_
31 | 	{
32 | 	// variables
33 | 		SDL_Event		event;
34 | 		Editable<bool>	wasProcessed;
35 | 		
36 | 	// methods
37 | 		OnSDLWindowRawMessage () : event{}, wasProcessed{false}
38 | 		{}
39 | 	};
40 | 
41 | 
42 | 	//
43 | 	// Platform Created Message
44 | 	//
45 | 	struct OnSDLPlatformCreated : _MsgBase_
46 | 	{
47 | 	// variables
48 | 		// TODO
49 | 
50 | 	// methods
51 | 		OnSDLPlatformCreated ()
52 | 		{}
53 | 	};
54 | 
55 | 
56 | }	// OSMsg
57 | }	// Engine
58 | 
59 | #endif	// PLATFORM_SDL
60 | 


--------------------------------------------------------------------------------
/Engine/Platforms/SDL/SDLObjectsConstructor.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/OS/IDs.h"
 6 | 
 7 | #ifdef PLATFORM_SDL
 8 | 
 9 | namespace Engine
10 | {
11 | namespace CreateInfo
12 | {
13 | 	struct RawInputHandler;
14 | 	struct Window;
15 | 	struct Platform;
16 | 
17 | }	// CreateInfo
18 | 
19 | 
20 | namespace Platforms
21 | {
22 | 
23 | 	//
24 | 	// SDL Objects Constructor
25 | 	//
26 | 
27 | 	class SDLObjectsConstructor final : public Noninstancable
28 | 	{
29 | 	// methods
30 | 	public:
31 | 		static void Register ();
32 | 		static void Unregister ();
33 | 		
34 | 		static OSModuleIDs GetModuleIDs ();
35 | 
36 | 		static ModulePtr  CreateSDLKeyInput (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::RawInputHandler &);
37 | 		static ModulePtr  CreateSDLMouseInput (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::RawInputHandler &);
38 | 		static ModulePtr  CreateSDLWindow (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::Window &);
39 | 		static ModulePtr  CreateSDLPlatform (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::Platform &);
40 | 	};
41 | 
42 | 
43 | }	// Platforms
44 | }	// Engine
45 | 
46 | #endif	// PLATFORM_SDL
47 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/Android/SwAndSurface.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/GPU/Context.h"
 6 | #include "Engine/Platforms/Soft/Impl/SWEnums.h"
 7 | 
 8 | #if defined( GRAPHICS_API_SOFT ) and defined( PLATFORM_ANDROID )
 9 | 
10 | namespace Engine
11 | {
12 | namespace PlatformSW
13 | {
14 | 
15 | 	//
16 | 	// Software Renderer Surface
17 | 	//
18 | 	class SwAndSurface
19 | 	{
20 | 	// types
21 | 	private:
22 | 		using AWindow_t	= DeferredTypeFrom<void*>;
23 | 
24 | 
25 | 	// variables
26 | 	private:
27 | 		AWindow_t	_nativeWindow;
28 | 		uint2		_size;
29 | 
30 | 
31 | 	// methods
32 | 	public:
33 | 		SwAndSurface ();
34 | 		
35 | 		bool Create (const AWindow_t &wnd, INOUT GraphicsSettings &vs);
36 | 		void Destroy ();
37 | 		
38 | 		void SwapBuffers ();
39 | 	};
40 | 
41 | 	
42 | 	using SWSurface	= SwAndSurface;
43 | 
44 | }	// PlatformSW
45 | }	// Engine
46 | 
47 | #endif	// GRAPHICS_API_SOFT and PLATFORM_ANDROID
48 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/Impl/SWDeviceProperties.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Soft/Impl/SWEnums.h"
 6 | 
 7 | #ifdef GRAPHICS_API_SOFT
 8 | 
 9 | namespace Engine
10 | {
11 | namespace PlatformSW
12 | {
13 | 
14 | 	//
15 | 	// Device Properties
16 | 	//
17 | 	static constexpr struct _SWDeviceProperties
18 | 	{
19 | 		static constexpr struct _Limits
20 | 		{
21 | 			static constexpr uint	maxPushConstantsSize	= 256u;			// 256 bytes
22 | 			static constexpr uint	maxUpdateBufferSize		= 65536u;		// bytes
23 | 			static constexpr uint	maxUniformBufferRange	= 64u << 10;	// 64Kb
24 | 			static constexpr uint	maxStorageBufferRange	= 2u << 30;		// 2 Gb
25 | 
26 | 			static constexpr uint	maxComputeSharedMemorySize		= 48 << 10;	// 48 Kb
27 | 			static constexpr uint	maxComputeWorkGroupInvocations	= 1536;
28 | 			static constexpr uint3	maxComputeWorkGroupSize			= uint3( 1536, 1024, 64 );		// group local size
29 | 			static constexpr uint3	maxComputeWorkGroupCount		= uint3( 2147483647, 65535, 65535 );
30 | 
31 | 			static constexpr int	maxProgramTexelOffset			= 16;
32 | 			static constexpr int	minProgramTexelOffset			= -16;
33 | 
34 | 		}	limits {};
35 | 
36 | 		static constexpr struct _Features
37 | 		{
38 | 		}	features {};
39 | 
40 | 		static constexpr bool	vulkanCompatibility	= true;
41 | 
42 | 	}	SWDeviceProperties {};
43 | 
44 | 
45 | }	// PlatformSW
46 | }	// Engine
47 | 
48 | #endif	// GRAPHICS_API_SOFT
49 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/Impl/SWEnums.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Config/Engine.Config.h"
 6 | 
 7 | #ifdef GRAPHICS_API_SOFT
 8 | 
 9 | #include "Engine/Platforms/Public/GPU/BufferEnums.h"
10 | #include "Engine/Platforms/Public/GPU/ImageEnums.h"
11 | #include "Engine/Platforms/Public/GPU/ShaderEnums.h"
12 | #include "Engine/Platforms/Public/GPU/VertexEnums.h"
13 | 
14 | namespace Engine
15 | {
16 | namespace PlatformSW
17 | {
18 | 	using namespace Engine::Platforms;
19 | 
20 | 
21 | }	// PlatformSW
22 | }	// Engine
23 | 
24 | #endif	// GRAPHICS_API_SOFT
25 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/ShaderLang/SWLangArray.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Soft/ShaderLang/SWLangCommon.h"
 6 | 
 7 | #ifdef GRAPHICS_API_SOFT
 8 | 
 9 | namespace SWShaderLang
10 | {
11 | namespace Impl
12 | {
13 | 
14 | 	//
15 | 	// Static Array
16 | 	//
17 | 
18 | 	template <typename T, usize I>
19 | 	struct SWArray final
20 | 	{
21 | 		STATIC_ASSERT( I > 0 );
22 | 
23 | 	// variables
24 | 	private:
25 | 		T	_elements[I];
26 | 
27 | 
28 | 	// methods
29 | 	public:
30 | 		SWArray () {}
31 | 
32 | 		GX_DEFCOPYCTOR_ASSIGN( SWArray );
33 | 
34 | 		T &  operator [] (const usize index)
35 | 		{
36 | 			ASSERT( index < I );
37 | 			return _elements[index];
38 | 		}
39 | 
40 | 		T const &  operator [] (const usize index) const
41 | 		{
42 | 			ASSERT( index < I );
43 | 			return _elements[index];
44 | 		}
45 | 
46 | 		bool operator == (const SWArray<T,I> &right) const
47 | 		{
48 | 			FOR( i, _elements ) {
49 | 				if ( not glm::all( _elements[i] == right._elements[i] ) )
50 | 					return false;
51 | 			}
52 | 			return true;
53 | 		}
54 | 
55 | 		bool operator != (const SWArray<T,I> &right) const {
56 | 			return not (*this == right);
57 | 		}
58 | 	};
59 | 
60 | }	// Impl
61 | }	// SWShaderLang
62 | 
63 | #endif	// GRAPHICS_API_SOFT
64 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/ShaderLang/SWLangCommon.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Config/Engine.Config.h"
 6 | 
 7 | #ifdef GRAPHICS_API_SOFT
 8 | 
 9 | #include "Engine/Platforms/Public/GPU/PixelFormatEnums.h"
10 | #include "Engine/Platforms/Public/GPU/ShaderEnums.h"
11 | 
12 | #include "Engine/Platforms/Soft/Impl/SWEnums.h"
13 | #include "Engine/Platforms/Soft/Impl/SWMessages.h"
14 | #include "Engine/Platforms/Soft/ShaderLang/SWLangGLM.h"
15 | 
16 | namespace SWShaderLang
17 | {
18 | namespace Impl
19 | {
20 | 
21 | 	using namespace GX_STL::GXMath;
22 | 
23 | 	using EStorageAccess	= Engine::Platforms::EShaderMemoryModel;
24 | 
25 | 	using EMemoryAccess		= Engine::Base::EMemoryAccess;
26 | 
27 | }	// Impl
28 | }	// SWShaderLang
29 | 
30 | #endif	// GRAPHICS_API_SOFT
31 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/ShaderLang/gen_Image.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	This is generated file, don't change anything!
 3 | */
 4 | 
 5 | namespace SWShaderLang
 6 | {
 7 | 
 8 | 	// imageLoad
 9 | 	template <typename GenType, Impl::EStorageAccess::type Acs> GenType imageLoad (gimage2D<GenType,Acs> &image, ivec2 p)  { return image.Load( _RCast<Impl::int2>(p) ); }
10 | 
11 | 	// imageStore
12 | 	template <typename GenType, Impl::EStorageAccess::type Acs> void imageStore (gimage2D<GenType,Acs> &image, ivec2 p, const GenType &data)  { return image.Store( _RCast<Impl::int2>(p), data ); }
13 | 
14 | }	// SWShaderLang
15 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Soft/Windows/SwWinSurface.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/GPU/Context.h"
 6 | #include "Engine/Platforms/Soft/Impl/SWEnums.h"
 7 | 
 8 | #if defined( GRAPHICS_API_SOFT ) and defined( PLATFORM_WINDOWS )
 9 | 
10 | namespace Engine
11 | {
12 | namespace PlatformSW
13 | {
14 | 
15 | 	//
16 | 	// Software Renderer Surface
17 | 	//
18 | 	class SwWinSurface
19 | 	{
20 | 	// types
21 | 	private:
22 | 		using HWND_t	= DeferredTypeFrom<void*>;
23 | 		using HDC_t		= DeferredTypeFrom<void*>;
24 | 
25 | 
26 | 	// variables
27 | 	private:
28 | 		HWND_t		_window;
29 | 		HDC_t		_mainDC;
30 | 		HDC_t		_secondaryDC;
31 | 		uint2		_size;
32 | 
33 | 
34 | 	// methods
35 | 	public:
36 | 		SwWinSurface ();
37 | 		
38 | 		bool Create (const HWND_t &wnd, INOUT GraphicsSettings &vs);
39 | 		void Destroy ();
40 | 		
41 | 		void SwapBuffers ();
42 | 	};
43 | 
44 | 	
45 | 	using SWSurface	= SwWinSurface;
46 | 
47 | }	// PlatformSW
48 | }	// Engine
49 | 
50 | #endif	// GRAPHICS_API_SOFT and PLATFORM_WINDOWS
51 | 


--------------------------------------------------------------------------------
/Engine/Platforms/VR/VRObjectsConstructor.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Engine/Platforms/VR/VRObjectsConstructor.h"
 4 | #include "Engine/Platforms/Public/GPU/VR.h"
 5 | 
 6 | namespace Engine
 7 | {
 8 | namespace Platforms
 9 | {
10 | 
11 | /*
12 | =================================================
13 | 	Register
14 | =================================================
15 | */
16 | 	void VRObjectsConstructor::Register ()
17 | 	{
18 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
19 | 
20 | 		#ifdef GX_EMULATOR_VR
21 | 			mf->Register( EmulatorVRThreadModuleID, &CreateEmulatorVRThread );
22 | 		#endif
23 | 
24 | 		#ifdef PLATFORM_OCULUS_VR
25 | 			mf->Register( GLEmulatorVRFramebufferModuleID, &CreateOculusVRThread );
26 | 		#endif
27 | 	}
28 | 	
29 | /*
30 | =================================================
31 | 	Unregister
32 | =================================================
33 | */
34 | 	void VRObjectsConstructor::Unregister ()
35 | 	{
36 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
37 | 		
38 | 		#ifdef GX_EMULATOR_VR
39 | 			mf->UnregisterAll( EmulatorVRThreadModuleID );
40 | 		#endif
41 | 
42 | 		#ifdef PLATFORM_OCULUS_VR
43 | 			mf->UnregisterAll( GLEmulatorVRFramebufferModuleID );
44 | 		#endif
45 | 	}
46 | 
47 | }	// Platforms
48 | }	// Engine
49 | 


--------------------------------------------------------------------------------
/Engine/Platforms/VR/VRObjectsConstructor.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace CreateInfo
10 | {
11 | 	struct VRThread;
12 | 	struct VRFramebuffer;
13 | 
14 | }	// CreateInfo
15 | 
16 | 
17 | namespace Platforms
18 | {
19 | 	// Emulator
20 | 	static constexpr TModID::type  EmulatorVRThreadModuleID			= "evr.thread"_TModID;
21 | 	static constexpr OModID::type  EmulatorVRFramebufferModuleID	= "evr.fbo"_OModID;
22 | 	
23 | 	// Oculus VR
24 | 	static constexpr TModID::type  OculusVRThreadModuleID			= "oculus.thrd"_TModID;
25 | 	static constexpr OModID::type  GLOculusVRFramebufferModuleID	= "gl.ovr.fbo"_OModID;
26 | 
27 | 
28 | 	
29 | 	//
30 | 	// VR Objects Constructor
31 | 	//
32 | 
33 | 	class VRObjectsConstructor final : public Noninstancable
34 | 	{
35 | 	// methods
36 | 	public:
37 | 		static void Register ();
38 | 		static void Unregister ();
39 | 
40 | 		static ModulePtr CreateEmulatorVRThread (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::VRThread &);
41 | 
42 | 		static ModulePtr CreateOculusVRThread (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::VRThread &);
43 | 	};
44 | 
45 | 
46 | }	// Platforms
47 | }	// Engine
48 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Vulkan/110/Vk1BaseObject.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/Config/Engine.Config.h"
 6 | 
 7 | #ifdef GRAPHICS_API_VULKAN
 8 | 
 9 | #include "Engine/Platforms/Vulkan/110/Vk1Device.h"
10 | #include "Engine/Platforms/Vulkan/110/Vk1Messages.h"
11 | 
12 | namespace Engine
13 | {
14 | namespace PlatformVK
15 | {
16 | 
17 | 	//
18 | 	// Vulkan Base Object
19 | 	//
20 | 
21 | 	class Vk1BaseObject : public StaticRefCountedObject
22 | 	{
23 | 	// variables
24 | 	private:
25 | 		Ptr< Vk1Device >	_vkDevice;
26 | 
27 | 
28 | 	// emthods
29 | 	public:
30 | 		explicit Vk1BaseObject (Ptr<Vk1Device> dev) : _vkDevice(dev) {}
31 | 
32 | 		ND_ Ptr< Vk1Device >	GetDevice ()	const	{ return _vkDevice; }
33 | 		ND_ vk::VkDevice		GetVkDevice ()	const	{ return _vkDevice and _vkDevice->IsDeviceCreated() ? _vkDevice->GetLogicalDevice() : null; }
34 | 	};
35 | 
36 | 
37 | }	// PlatformVK
38 | }	// Engine
39 | 
40 | #endif	// GRAPHICS_API_VULKAN
41 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Vulkan/Android/VkAndSurface.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Vulkan/110/vulkan1.h"
 6 | 
 7 | #if defined( GRAPHICS_API_VULKAN ) and defined( PLATFORM_ANDROID )
 8 | 
 9 | #include "Engine/Platforms/Public/Tools/WindowHelper.h"
10 | 
11 | namespace Engine
12 | {
13 | namespace PlatformVK
14 | {
15 | 
16 | 	//
17 | 	// Vulkan Android Surface
18 | 	//
19 | 
20 | 	class VkAndSurface
21 | 	{
22 | 	// types
23 | 	public:
24 | 		using AWindow_t = DeferredTypeFrom<void*>;
25 | 
26 | 
27 | 	// methods
28 | 	public:
29 | 		VkAndSurface ();
30 | 		~VkAndSurface ();
31 | 
32 | 		bool Create (vk::VkInstance instance, const PlatformTools::WindowHelper::WinAPIWindow &, OUT vk::VkSurfaceKHR &surface);
33 | 		void Destroy ();
34 | 		void RequestExtensions (INOUT Array<const char*> &ext);
35 | 	};
36 | 
37 | 
38 | 	using Vk1Surface	= VkAndSurface;
39 | 
40 | 
41 | }	// PlatformVK
42 | }	// Engine
43 | 
44 | #endif	// GRAPHICS_API_VULKAN and PLATFORM_ANDROID
45 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Vulkan/Windows/VkWinSurface.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Vulkan/110/vulkan1.h"
 6 | 
 7 | #if defined( GRAPHICS_API_VULKAN ) and defined( PLATFORM_WINDOWS )
 8 | 
 9 | #include "Engine/Platforms/Public/Tools/WindowHelper.h"
10 | 
11 | namespace Engine
12 | {
13 | namespace PlatformVK
14 | {
15 | 
16 | 	//
17 | 	// Vulkan Windows Surface
18 | 	//
19 | 
20 | 	class VkWinSurface
21 | 	{
22 | 	// types
23 | 	public:
24 | 		using HWND_t	= DeferredTypeFrom<void*>;
25 | 
26 | 	// methods
27 | 	public:
28 | 		VkWinSurface ();
29 | 		~VkWinSurface ();
30 | 
31 | 		bool Create (vk::VkInstance instance, const PlatformTools::WindowHelper::WinAPIWindow &, OUT vk::VkSurfaceKHR &surface);
32 | 		void Destroy ();
33 | 		void RequestExtensions (INOUT Array<const char*> &ext);
34 | 	};
35 | 
36 | 
37 | 	using Vk1Surface	= VkWinSurface;
38 | 
39 | 
40 | }	// PlatformVK
41 | }	// Engine
42 | 
43 | #endif	// GRAPHICS_API_VULKAN and PLATFORM_WINDOWS
44 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Windows/WinDisplay.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Common/Platforms.h"
 6 | #include "Core/Config/Engine.Config.h"
 7 | 
 8 | #ifdef PLATFORM_WINDOWS
 9 | 
10 | #include "Engine/Platforms/Public/OS/Display.h"
11 | #include "Engine/Platforms/Public/OS/Platform.h"
12 | 
13 | namespace Engine
14 | {
15 | namespace PlatformWin
16 | {
17 | 	using namespace Engine::Platforms;
18 | 
19 | 
20 | 	//
21 | 	// Windows Display Helper
22 | 	//
23 | 
24 | 	struct WinDisplay final
25 | 	{
26 | 	// types
27 | 	private:
28 | 		using HMONITOR_t			= DeferredTypeFrom<void*>;
29 | 
30 | 		using Displays_t			= OSMsg::GetDisplays::Displays_t;
31 | 		using MonitorHandles_t		= FixedSizeArray< HMONITOR_t, Displays_t::MemoryContainer_t::SIZE >;
32 | 
33 | 
34 | 	// variables
35 | 	private:
36 | 		Displays_t			_displays;
37 | 		MonitorHandles_t	_monitors;
38 | 
39 | 
40 | 	// methods
41 | 	public:
42 | 		WinDisplay ();
43 | 
44 | 		bool Update ();
45 | 
46 | 		ArrayCRef<Display> GetDisplays () const		{ return _displays; }
47 | 
48 | 	private:
49 | 		float2 _ScreenPhysicalSize () const;
50 | 		uint   _GetDisplayFrequency () const;
51 | 	};
52 | 
53 | 
54 | }	// PlatformWin
55 | }	// Engine
56 | 
57 | #endif	// PLATFORM_WINDOWS
58 | 


--------------------------------------------------------------------------------
/Engine/Platforms/Windows/WinObjectsConstructor.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Public/OS/IDs.h"
 6 | 
 7 | #ifdef PLATFORM_WINDOWS
 8 | 
 9 | namespace Engine
10 | {
11 | namespace CreateInfo
12 | {
13 | 	struct RawInputHandler;
14 | 	struct Window;
15 | 	struct Platform;
16 | 
17 | }	// CreateInfo
18 | 
19 | 
20 | namespace Platforms
21 | {
22 | 
23 | 	//
24 | 	// Windows Objects Constructor
25 | 	//
26 | 
27 | 	class WinObjectsConstructor final : public Noninstancable
28 | 	{
29 | 	// methods
30 | 	public:
31 | 		static void Register ();
32 | 		static void Unregister ();
33 | 		
34 | 		static OSModuleIDs GetModuleIDs ();
35 | 
36 | 		static ModulePtr  CreateWinKeyInput (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::RawInputHandler &);
37 | 		static ModulePtr  CreateWinMouseInput (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::RawInputHandler &);
38 | 		static ModulePtr  CreateWinWindow (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::Window &);
39 | 		static ModulePtr  CreateWinPlatform (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::Platform &);
40 | 	};
41 | 
42 | 
43 | }	// Platforms
44 | }	// Engine
45 | 
46 | #endif	// PLATFORM_WINDOWS
47 | 


--------------------------------------------------------------------------------
/Engine/Profilers/Engine.Profilers.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | */
 4 | 
 5 | #pragma once
 6 | 
 7 | 
 8 | #include "Engine/Profilers/Public/GpuStatistic.h"
 9 | 
10 | 


--------------------------------------------------------------------------------
/Engine/Profilers/Impl/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Engine/Profilers/Impl/ProfilerObjectsConstructor.h"
 4 | #include "Engine/Profilers/Public/GpuStatistic.h"
 5 | 
 6 | namespace Engine
 7 | {
 8 | namespace Profilers
 9 | {
10 | 
11 | /*
12 | =================================================
13 | 	RegisterProfilers
14 | =================================================
15 | */
16 | 	void RegisterProfilers ()
17 | 	{
18 | 		using POC = ProfilerObjectsConstructor;
19 | 		
20 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
21 | 
22 | 		CHECK( mf->Register( FPSCounterModuleID, &POC::CreateFPSCounter ) );
23 | 	}
24 | 	
25 | /*
26 | =================================================
27 | 	UnregisterProfilers
28 | =================================================
29 | */
30 | 	void UnregisterProfilers ()
31 | 	{
32 | 		auto	mf = GetMainSystemInstance()->GlobalSystems()->modulesFactory;
33 | 
34 | 		mf->UnregisterAll( FPSCounterModuleID );
35 | 	}
36 | 
37 | }	// Profilers
38 | }	// Engine


--------------------------------------------------------------------------------
/Engine/Profilers/Impl/ProfilerObjectsConstructor.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Profilers/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace CreateInfo
10 | {
11 | 	struct FPSCounter;
12 | 
13 | }	// CreateInfo
14 | 
15 | 
16 | namespace Profilers
17 | {
18 | 
19 | 	//
20 | 	// Profiler Objects Constructor
21 | 	//
22 | 
23 | 	class ProfilerObjectsConstructor final : public Noninstancable
24 | 	{
25 | 	// methods
26 | 	public:
27 | 		static ModulePtr CreateFPSCounter (ModuleMsg::UntypedID_t, GlobalSystemsRef, const CreateInfo::FPSCounter &);
28 | 	};
29 | 
30 | 
31 | }	// Profilers
32 | }	// Engine
33 | 


--------------------------------------------------------------------------------
/Engine/Profilers/Public/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Engine.Base.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Profilers
10 | {
11 | 	using namespace Engine::Base;
12 | 
13 | 	void RegisterProfilers ();
14 | 	void UnregisterProfilers ();
15 | 
16 | }	// Profilers
17 | }	// Engine
18 | 


--------------------------------------------------------------------------------
/Engine/Profilers/Public/GpuStatistic.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Profilers/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace CreateInfo
10 | {
11 | 
12 | 	//
13 | 	// FPS Counter Create Info
14 | 	//
15 | 	struct FPSCounter
16 | 	{
17 | 		TimeD		interval	= 1.0_sec;
18 | 	};
19 | 
20 | }	// CreateInfo
21 | 
22 | 
23 | namespace ProfilerMsg
24 | {
25 | 
26 | 	
27 | 
28 | }	// ProfilerMsg
29 | }	// Engine
30 | 


--------------------------------------------------------------------------------
/Engine/Profilers/Public/IDs.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Profilers/Public/Common.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Profilers
10 | {
11 | 
12 | 	static constexpr OModID::type  FPSCounterModuleID		= "fps-count"_OModID;
13 | 	
14 | 
15 | }	// Profilers
16 | }	// Engine
17 | 


--------------------------------------------------------------------------------
/Engine/README.md:
--------------------------------------------------------------------------------
1 | # Engine
2 | * Base - module, tasks, threads.
3 | * Platforms - wrappers for WinAPI, OpenGL, OpenCL, Vulkan and other.
4 | * Graphics - high level graphics api (deprecated).
5 | * FrameGraph - high level graphics abstraction layer (WIP).
6 | * Scene - render technique, scene objects and other.
7 | * Profilers - fps counter and other.
8 | * Debugger - some debug tools for graphics and other (WIP).


--------------------------------------------------------------------------------
/Engine/ResourcePacker/FilePacker/BinaryFilePacker.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/ResourcePacker/FilePacker/BinaryFilePacker.cpp


--------------------------------------------------------------------------------
/Engine/ResourcePacker/FilePacker/BinaryFilePacker.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ResourcePacker/FilePacker/IFilePacker.h"
 6 | 
 7 | namespace ResPack
 8 | {
 9 | 
10 | 	//
11 | 	// Binary File Packer
12 | 	//
13 | /*
14 | 	class BinaryFilePacker final : public IFilePacker
15 | 	{
16 | 	// variables
17 | 	private:
18 | 		BinaryArray		_data;
19 | 
20 | 
21 | 	// methods
22 | 	public:
23 | 		BinaryFilePacker ();
24 | 
25 | 		bool Load (StringCRef filename) override;
26 | 		bool Save (StringCRef filename) override;
27 | 	};*/
28 | 
29 | }	// ResPack
30 | 


--------------------------------------------------------------------------------
/Engine/ResourcePacker/FilePacker/IFileSystemPacker.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ResourcePacker/Packer/Common.h"
 6 | 
 7 | namespace ResPack
 8 | {
 9 | 
10 | 	//
11 | 	// File System Packer interface
12 | 	//
13 | 
14 | 	class IFileSystemPacker : public RefCountedObject<>
15 | 	{
16 | 	// types
17 | 	public:
18 | 		class IOutputTextStream
19 | 		{
20 | 		// interface
21 | 		public:
22 | 			virtual ~IOutputTextStream () {}
23 | 
24 | 			virtual bool Append (StringCRef data) = 0;
25 | 			virtual BytesU GetPosition () const = 0;
26 | 		};
27 | 		
28 | 		class IOutputBinStream
29 | 		{
30 | 		// interface
31 | 		public:
32 | 			virtual ~IOutputBinStream () {}
33 | 
34 | 			virtual bool Append (BinArrayCRef data) = 0;
35 | 			virtual BytesU GetPosition () const = 0;
36 | 		};
37 | 
38 | 
39 | 	// interface
40 | 	public:
41 | 		virtual ~IFileSystemPacker () {}
42 | 
43 | 		virtual UniquePtr<IOutputTextStream>  SaveText (StringCRef filename) = 0;
44 | 		virtual UniquePtr<IOutputBinStream>   SaveBinary (StringCRef filename) = 0;
45 | 		
46 | 		virtual Date  GetFileLastModificationTime (StringCRef filename) const = 0;
47 | 	};
48 | 
49 | 	SHARED_POINTER( IFileSystemPacker );
50 | 
51 | }	// ResPack
52 | 


--------------------------------------------------------------------------------
/Engine/ResourcePacker/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Engine/ResourcePacker/Packer/ResourcePacker.h"
 4 | 
 5 | using namespace ResPack;
 6 | 
 7 | int main (int argc, char** argv)
 8 | {
 9 | 	CHECK_ERR( argv > 0 );
10 | 
11 | 	auto packer = ResPack::ResourcePacker::Instance();
12 | 
13 | 	CHECK_ERR( packer->Initialize(), -1 );
14 | 
15 | 	Array<String>	res_files;
16 | 
17 | 	for (int i = 1; i < argc; ++i)
18 | 	{
19 | 		StringCRef	key = argv[i];
20 | 		StringCRef	value;
21 | 
22 | 		if ( ++i < argc )
23 | 			value = argv[i];
24 | 
25 | 		if ( key == "-R" or key == "-r" )
26 | 		{
27 | 			res_files << value;
28 | 		}
29 | 		else
30 | 		{
31 | 			RETURN_ERR( "unsupported command arg: " << key, 1 );
32 | 		}
33 | 	}
34 | 
35 | 	packer->SetExecutable( argv[0] );
36 | 
37 | 	for (auto& res : res_files) {
38 | 		packer->Run( res );
39 | 	}	
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/Engine/ResourcePacker/Packer/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Core/STL/Types/UniquePtr.h"
 6 | #include "Core/STL/Containers/HashMap.h"
 7 | #include "Core/STL/Containers/Stack.h"
 8 | 
 9 | #include "Core/Script/Core.Script.h"
10 | 
11 | namespace ResPack
12 | {
13 | 
14 | 	using namespace GX_STL;
15 | 	using namespace GX_STL::GXTypes;
16 | 
17 | 
18 | 	//
19 | 	// Script Helper
20 | 	//
21 | 	struct ScriptHelper final : Noninstancable
22 | 	{
23 | 		static bool RunScript (StringCRef filename);
24 | 		
25 | 		static StringCRef CurrentFileName ();
26 | 
27 | 		static GXScript::ScriptEnginePtr GetScriptEngine ();
28 | 	};
29 | 
30 | }	// ResPack
31 | 


--------------------------------------------------------------------------------
/Engine/ResourcePacker/Packer/ResourcePacker.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/ResourcePacker/Pipelines/PipelineConverter.h"
 6 | #include "Engine/ResourcePacker/FilePacker/IFileSystemPacker.h"
 7 | 
 8 | namespace ResPack
 9 | {
10 | 
11 | 	//
12 | 	// Resource Packer
13 | 	//
14 | 
15 | 	class ResourcePacker final
16 | 	{
17 | 		friend struct ScriptHelper;
18 | 
19 | 	// types
20 | 	private:
21 | 		class ScriptResourcePacker;
22 | 
23 | 		using PipelinePtr				= PipelineConverter::PipelinePtr;
24 | 		using PipelineConverterConfig	= PipelineConverter::ConverterConfig;
25 | 
26 | 
27 | 	// variables
28 | 	private:
29 | 		PipelineConverter		_pplnConverter;
30 | 		String					_exeName;
31 | 
32 | 
33 | 	// methods
34 | 	protected:
35 | 		ResourcePacker ();
36 | 		~ResourcePacker ();
37 | 
38 | 	public:
39 | 		static Ptr<ResourcePacker> Instance ();
40 | 
41 | 		bool Initialize ();
42 | 
43 | 		void SetExecutable (StringCRef name);
44 | 
45 | 		bool Run (StringCRef res);
46 | 		
47 | 		void AddPipeline (const PipelinePtr &ppln);
48 | 
49 | 		StringCRef GetExecutableName () const	{ return _exeName; }
50 | 
51 | 
52 | 	private:
53 | 		//bool _PackFile (IFilePackerPtr &&file, StringCRef input, StringCRef output);
54 | 
55 | 		static void _Bind (GXScript::ScriptEnginePtr se);
56 | 	};
57 | 
58 | }	// ResPack
59 | 


--------------------------------------------------------------------------------
/Engine/Scene/Engine.Scene.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | 	High level graphics interface.
 4 | 
 5 | 	- Scene
 6 | 		- Terrain
 7 | 		- Camera
 8 | 		- Particles
 9 | 		...
10 | 	- RenderTechnique
11 | 		- RayTracing / RayMarching
12 | 		- Deferred ...
13 | 		- Forward ...
14 | 		...
15 | */
16 | 
17 | #pragma once
18 | 
19 | 
20 | #include "Engine/Scene/Public/Camera.h"
21 | #include "Engine/Scene/Public/Surface.h"
22 | #include "Engine/Scene/Public/Scene.h"
23 | 


--------------------------------------------------------------------------------
/Engine/Scene/Public/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Platforms/Engine.Platforms.h"
 6 | #include "Engine/Graphics/Engine.Graphics.h"
 7 | 
 8 | namespace Engine
 9 | {
10 | namespace Scene
11 | {
12 | 	using namespace Engine::Base;
13 | 	using namespace GX_STL::GXMath;
14 | 	
15 | 	
16 | 	void RegisterScene ();
17 | 	void UnregisterScene ();
18 | 
19 | }	// Scene
20 | 
21 | 
22 | namespace SceneMsg
23 | {
24 | 	using namespace Engine::_BaseMessages_;
25 | 
26 | }	// SceneMsg
27 | }	// Engine
28 | 


--------------------------------------------------------------------------------
/Engine/Scene/Public/Scene.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Scene/Public/IDs.h"
 6 | 
 7 | namespace Engine
 8 | {
 9 | namespace Scene
10 | {
11 | 
12 | 
13 | }	// Scene
14 | 
15 | 
16 | namespace CreateInfo
17 | {
18 | 	
19 | 	//
20 | 	// Scene Manager Create Info
21 | 	//
22 | 	struct SceneManager
23 | 	{
24 | 	// types
25 | 		struct VRSettings
26 | 		{
27 | 			GXMath::uint2		eyeTextureDimension;		// dimension of per eye textures
28 | 			bool				layered		= false;		// create texture array or use multiview extension, depended of implementation
29 | 			bool				enabled		= false;
30 | 		};
31 | 
32 | 	// variables
33 | 		Platforms::GraphicsSettings		settings;		// this is default settings for all threads
34 | 		VRSettings						vrSettings;
35 | 
36 | 	// methods
37 | 		SceneManager () {}
38 | 	};
39 | 
40 | 
41 | 	//
42 | 	// Scene Main Thread Create Info
43 | 	//
44 | 	struct SceneMain
45 | 	{
46 | 	};
47 | 
48 | 
49 | 	//
50 | 	// Scene Renderer Main Thread Create Info
51 | 	//
52 | 	struct SceneRenderer
53 | 	{
54 | 	};
55 | 
56 | 
57 | 	//
58 | 	// Scene Physics Main Thread Create Info
59 | 	//
60 | 	struct ScenePhysics
61 | 	{
62 | 	};
63 | 
64 | 
65 | 	//
66 | 	// Scene Logic (AI, Gameplay) Main Thread Create Info
67 | 	//
68 | 	struct SceneLogic
69 | 	{
70 | 	};
71 | 
72 | }	// CreateInfo
73 | 
74 | 
75 | namespace SceneMsg
76 | {
77 | 	
78 | 
79 | }	// SceneMsg
80 | }	// Engine
81 | 


--------------------------------------------------------------------------------
/Engine/Scene/Surface/OffscreenSurface.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/Scene/Surface/OffscreenSurface.cpp


--------------------------------------------------------------------------------
/Engine/Scene/Surface/VideoRecorderSurface.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Engine/Scene/Surface/VideoRecorderSurface.cpp


--------------------------------------------------------------------------------
/EngineTests/Base/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Engine.Base.h"
 6 | #include "Engine/Platforms/Engine.Platforms.h"
 7 | 
 8 | using namespace Engine;
 9 | using namespace Engine::Base;
10 | using namespace Engine::Platforms;
11 | 


--------------------------------------------------------------------------------
/EngineTests/Base/Graphics/Test.GWindow.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "GApp.h"
 4 | 	
 5 | extern void Test_GWindow ()
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Base" ) );
 8 | 
 9 | 	#ifdef GRAPHICS_API_OPENGL
10 | 	{
11 | 		GApp	app;
12 | 		app.Initialize( "GL 4.5"_GAPI );
13 | 
14 | 		// main loop
15 | 		for (; app.Update();) {}
16 | 
17 | 		app.Quit();
18 | 	}
19 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
20 | 	#endif
21 | 	
22 | 	#ifdef GRAPHICS_API_VULKAN
23 | 	{
24 | 		GApp	app;
25 | 		app.Initialize( "VK 1.0"_GAPI );
26 | 
27 | 		// main loop
28 | 		for (; app.Update();) {}
29 | 
30 | 		app.Quit();
31 | 	}
32 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
33 | 	#endif
34 | }
35 | 


--------------------------------------------------------------------------------
/EngineTests/Base/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Common.h"
 4 | 
 5 | extern void Test_Window ();
 6 | extern void Test_GWindow ();
 7 | extern void Test_CWindow ();
 8 | 
 9 | 
10 | int main ()
11 | {
12 | 	Logger::GetInstance()->Open( "log", false );
13 | 
14 | 	//Test_Window();
15 | 	Test_GWindow();
16 | 	//Test_CWindow();
17 | 
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/EngineTests/Base/Pipelines/Default2.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	GraphicsPipeline	ppln;
 6 | 
 7 | 	ppln.shaders.vertex.LoadSelf();
 8 | 	ppln.shaders.fragment.LoadSelf();
 9 | 
10 | 	ppln.renderState.inputAssembly.topology = EPrimitive_TriangleList;
11 | 
12 | 	ppln.dynamicStates |= EPipelineDynamicState_Viewport;
13 | 	ppln.dynamicStates |= EPipelineDynamicState_Scissor;
14 | }
15 | #endif
16 | //-----------------------------------------------------------------------------
17 | 
18 | 
19 | #ifdef SHADER
20 | #if SHADER & SH_VERTEX
21 | 
22 | in  float2	at_Position;
23 | in  float2	at_Texcoord;
24 | 
25 | out float2	v_Texcoord;
26 | 
27 | void main() {
28 |     gl_Position	= float4( at_Position, 0.0, 1.0 );
29 | 	v_Texcoord	= at_Texcoord;
30 | }
31 | #endif
32 | //-----------------------------------------------------------------------------
33 | 
34 | 
35 | #if SHADER & SH_FRAGMENT
36 | 
37 | layout (std140) uniform UB
38 | {
39 | 	float4	color;
40 | 
41 | } ub;
42 | 
43 | uniform sampler2D un_ColorTexture;
44 | 
45 | in  float2	v_Texcoord;
46 | 
47 | out float4	out_Color;
48 | 
49 | void main() {
50 |     out_Color = texture(un_ColorTexture, v_Texcoord) * ub.color;
51 | }
52 | #endif
53 | #endif	// SHADER
54 | 


--------------------------------------------------------------------------------
/EngineTests/Base/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'default.cpp'
24 | void Create_default (PipelineTemplateDescription& descr);
25 | 
26 | // From file 'default2.cpp'
27 | void Create_default2 (PipelineTemplateDescription& descr);
28 | 
29 | }	// Pipelines
30 | 


--------------------------------------------------------------------------------
/EngineTests/Base/Pipelines/resources.as:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ResourcePacker	rpack;
 6 | 
 7 | 	// setup pipeline compiler
 8 | 	{
 9 | 		Pipeline_ConverterConfig	cfg;
10 | 		
11 | 		cfg.searchForSharedTypes	= true;
12 | 		cfg.addPaddingToStructs		= true;
13 | 		cfg.optimizeSource			= false;
14 | 		cfg.optimizeBindings		= true;
15 | 		cfg.minimalRebuild			= true;
16 | 		cfg.nameSpace				= "Pipelines";
17 | 		cfg.targets					|= EShaderFormat_GLSL_450;
18 | 		cfg.targets					|= EShaderFormat_VK_100_SPIRV;
19 | 		cfg.targets					|= EShaderFormat_CL_120;
20 | 		//cfg.targets				|= EShaderFormat_Soft_100_Exe;
21 | 
22 | 		rpack.SetConfig( cfg );
23 | 	}
24 | 
25 | 	// convert compute pipelines
26 | 	{
27 | 		rpack.AddAllPipelines( "" );
28 | 		rpack.ConvertPipelines( "" );
29 | 	}
30 | }
31 | #endif	// ANGELSCRIPT


--------------------------------------------------------------------------------
/EngineTests/Graphics/GApp.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Graphics/Engine.Graphics.h"
 6 | 
 7 | using namespace Engine;
 8 | using namespace Engine::Base;
 9 | using namespace Engine::Platforms;
10 | using namespace Engine::Graphics;
11 | 
12 | 
13 | class GApp final : public StaticRefCountedObject
14 | {
15 | // types
16 | private:
17 | 	using RenderPassMsgList_t = ModuleMsg::MessageListFrom< GpuMsg::GetRenderPassDescription >;
18 | 
19 | 
20 | // variables
21 | private:
22 | 	Ptr< Module >		ms;
23 | 	bool				looping		= true;
24 | 	GraphicsModuleIDs	ids;
25 | 
26 | 	ModulePtr			batchRenderer;
27 | 
28 | 	ModulePtr			gpipeline;
29 | 	ModulePtr			pipelineTemplate;
30 | 	ModulePtr			resourceTable;
31 | 	
32 | 	ModulePtr			texture;
33 | 	ModulePtr			sampler;
34 | 
35 | 	ModulePtr			cmdBuilder;
36 | 	ModulePtr			asyncCmdBuilder;
37 | 
38 | 	
39 | // methods
40 | public:
41 | 	GApp ();
42 | 
43 | 	bool Initialize (GAPI::type api);
44 | 	void Quit ();
45 | 	bool Update ();
46 | 	
47 | 	bool _GraphicsInit (const GpuMsg::DeviceCreated &);
48 | 	bool _GraphicsDelete (const GpuMsg::DeviceBeforeDestroy &);
49 | 	bool _Draw (const ModuleMsg::Update &);
50 | 	bool _OnWindowClosed (const OSMsg::WindowAfterDestroy &);
51 | 
52 | 	bool _CreatePipeline ();
53 | };
54 | 
55 | 


--------------------------------------------------------------------------------
/EngineTests/Graphics/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "GApp.h"
 4 | 
 5 | 
 6 | /*
 7 | =================================================
 8 | 	main
 9 | =================================================
10 | */
11 | int main ()
12 | {
13 | 	Logger::GetInstance()->Open( "log", false );
14 | 	
15 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Graphics" ) );
16 | 	
17 | 	#ifdef GRAPHICS_API_OPENGL
18 | 	{
19 | 		GApp	app;
20 | 		app.Initialize( "GL 4.5"_GAPI );
21 | 
22 | 		// main loop
23 | 		for (; app.Update();) {}
24 | 
25 | 		app.Quit();
26 | 	}
27 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
28 | 	#endif
29 | 
30 | 	#ifdef GRAPHICS_API_VULKAN
31 | 	{
32 | 		GApp	app;
33 | 		app.Initialize( "VK 1.0"_GAPI );
34 | 
35 | 		// main loop
36 | 		for (; app.Update();) {}
37 | 
38 | 		app.Quit();
39 | 	}
40 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
41 | 	#endif
42 | 
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/EngineTests/Graphics/Pipelines/Default3.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	GraphicsPipeline	ppln;
 6 | 
 7 | 	ppln.shaders.vertex.LoadSelf();
 8 | 	ppln.shaders.fragment.LoadSelf();
 9 | 	
10 | 	ppln.supportedTopology |= EPrimitive_TriangleList;
11 | 	ppln.supportedTopology |= EPrimitive_TriangleStrip;
12 | 
13 | 	ppln.dynamicStates |= EPipelineDynamicState_Viewport;
14 | 	ppln.dynamicStates |= EPipelineDynamicState_Scissor;
15 | }
16 | #endif
17 | //-----------------------------------------------------------------------------
18 | 
19 | 
20 | #ifdef SHADER
21 | #if SHADER & SH_VERTEX
22 | 
23 | in  float2	at_Position;
24 | in  float2	at_Texcoord;
25 | in  float4	at_Color;
26 | 
27 | out float2	v_Texcoord;
28 | out	float4	v_Color;
29 | 
30 | void main() {
31 |     gl_Position	= float4( at_Position, 0.0, 1.0 );
32 | 	v_Texcoord	= at_Texcoord;
33 | 	v_Color		= at_Color;
34 | }
35 | #endif
36 | //-----------------------------------------------------------------------------
37 | 
38 | 
39 | #if SHADER & SH_FRAGMENT
40 | 
41 | uniform sampler2D un_ColorTexture;
42 | 
43 | in  float2	v_Texcoord;
44 | in	float4	v_Color;
45 | 
46 | out float4	out_Color;
47 | 
48 | void main() {
49 |     out_Color = texture(un_ColorTexture, v_Texcoord) * v_Color;
50 | }
51 | #endif
52 | #endif	// SHADER
53 | 


--------------------------------------------------------------------------------
/EngineTests/Graphics/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'default3.cpp'
24 | void Create_default3 (PipelineTemplateDescription& descr);
25 | 
26 | }	// Pipelines
27 | 


--------------------------------------------------------------------------------
/EngineTests/Graphics/Pipelines/resources.as:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ResourcePacker	rpack;
 6 | 
 7 | 	// setup pipeline compiler
 8 | 	{
 9 | 		Pipeline_ConverterConfig	cfg;
10 | 		
11 | 		cfg.searchForSharedTypes	= true;
12 | 		cfg.addPaddingToStructs		= true;
13 | 		cfg.optimizeSource			= false;
14 | 		cfg.optimizeBindings		= true;
15 | 		cfg.minimalRebuild			= true;
16 | 		cfg.nameSpace				= "Pipelines";
17 | 		cfg.targets					|= EShaderFormat_GLSL_450;
18 | 		cfg.targets					|= EShaderFormat_VK_100_SPIRV;
19 | 		cfg.targets					|= EShaderFormat_CL_120;
20 | 		//cfg.targets				|= EShaderFormat_Soft_100_Exe;
21 | 
22 | 		rpack.SetConfig( cfg );
23 | 	}
24 | 
25 | 	// convert compute pipelines
26 | 	{
27 | 		rpack.AddAllPipelines( "" );
28 | 		rpack.ConvertPipelines( "" );
29 | 	}
30 | }
31 | #endif	// ANGELSCRIPT
32 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "Engine/Base/Engine.Base.h"
 6 | #include "Engine/Platforms/Engine.Platforms.h"
 7 | 
 8 | using namespace Engine;
 9 | using namespace Engine::Base;
10 | using namespace Engine::Platforms;
11 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/AtomicAdd.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | struct AtomicAdd_Struct
18 | {
19 | 	int		value;
20 | 	bool	found;
21 | };
22 | 
23 | layout(binding=0, std430) buffer AtomicAdd_SSBO
24 | {
25 | 	AtomicAdd_Struct	st;
26 | 	uint				result;
27 | 	uint				resultList[10];
28 | } ssb;
29 | 
30 | void main ()
31 | {
32 | 	uint r = atomicAdd( ssb.result, 1 );
33 | 
34 | 	if ( gl_GlobalInvocationID.x < ssb.resultList.length() )
35 | 	{
36 | 		ssb.resultList[gl_GlobalInvocationID.x] = r;
37 | 	}
38 | 
39 | 	if ( atomicAdd( ssb.st.value, -2 ) == 0 )
40 | 	{
41 | 		ssb.st.found = true;
42 | 	}
43 | }
44 | 
45 | #endif
46 | #endif	// SHADER
47 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/FindLSB.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | layout(binding=0, std430) writeonly buffer FindLSB_SSBO
18 | {
19 | 	 uint	results[16];
20 | 
21 | } ssb;
22 | 
23 | void main ()
24 | {
25 | 	for (int i = 0; i < ssb.results.length(); ++i)
26 | 	{
27 | 		int  j1 = i*2;
28 | 		int  j2 = 32 - j1;
29 | 		int  j3 = i+3;
30 | 		uint v  = uint( (1 << j1) | (1 << j2) | (1 << j3) );
31 | 
32 | 		ssb.results[i] = findLSB( v );
33 | 	}
34 | }
35 | 
36 | #endif
37 | #endif	// SHADER
38 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/FindMSB.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | layout(binding=0, std430) writeonly buffer FindMSB_SSBO
18 | {
19 | 	 uint	results[16];
20 | 
21 | } ssb;
22 | 
23 | void main ()
24 | {
25 | 	for (uint i = 0; i < ssb.results.length(); ++i)
26 | 	{
27 | 		uint  j1 = i * 2u;
28 | 		uint  j2 = min( 31u, 32u - j1 );
29 | 		uint  j3 = i + 3u;
30 | 		uint  v  = (1u << j1) | (1u << j2) | (1u << j3);
31 | 
32 | 		ssb.results[i] = findMSB( v );
33 | 	}
34 | }
35 | 
36 | #endif
37 | #endif	// SHADER
38 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/GlobalToLocal.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 
 9 | 	self.compute.LoadSelf();
10 | }
11 | #endif
12 | //-----------------------------------------------------------------------------
13 | 
14 | 
15 | #ifdef SHADER
16 | #if SHADER & SH_COMPUTE
17 | 
18 | layout(binding=0, std430) buffer GlobalToLocal_SSBO
19 | {
20 | 	uint	data[4];
21 | 	uint	results[2];
22 | } ssb;
23 | 
24 | 
25 | uint WithGlobalAccess (const uint data[4])
26 | {
27 | 	return data[0] + data[1] + data[2] + data[3];
28 | }
29 | 
30 | uint WithGlobalAccess2 (const uint data[4])
31 | {
32 | 	return WithGlobalAccess( data ) + 1;
33 | }
34 | 
35 | void main ()
36 | {
37 | 	ssb.results[0] = WithGlobalAccess( ssb.data );	// must be inlined in OpenCL 1.2, or use generic for 2.0
38 | 	//ssb.results[1] = WithGlobalAccess2( ssb.data );
39 | }
40 | 
41 | #endif
42 | #endif	// SHADER
43 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/Include.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 
 9 | 	self.compute.LoadSelf();
10 | }
11 | #endif
12 | //-----------------------------------------------------------------------------
13 | 
14 | 
15 | #ifdef SHADER
16 | #if SHADER & SH_COMPUTE
17 | 
18 | #include <Math/Math.glsl>
19 | 
20 | layout(binding=0, std430) writeonly buffer Include_SSBO
21 | {
22 | 	float	results[2];
23 | } ssb;
24 | 
25 | void main ()
26 | {
27 | 	ssb.results[0] = Wrap( 1.0f,  0.0f, 4.0f );
28 | 	ssb.results[1] = Wrap( 6.0f, -1.0f, 3.0f );
29 | }
30 | 
31 | #endif
32 | #endif	// SHADER
33 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/InlineAll.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GLSL_450;
 8 | 	self.localGroupSize = uint3(4,4,0);
 9 | 	self.compute.LoadSelf();
10 | }
11 | #endif
12 | //-----------------------------------------------------------------------------
13 | 
14 | 
15 | #ifdef SHADER
16 | #if SHADER & SH_COMPUTE
17 | 
18 | layout(binding=0, std430) writeonly buffer InlineAll_SSBO
19 | {
20 | 	 uint	results[gl_WorkGroupSize.x * gl_WorkGroupSize.y];
21 | } ssb;
22 | 
23 | 
24 | uint Hash (uint value)
25 | {
26 | 	uint res = ((value << 7) | (value << 11));
27 | 	return res;
28 | }
29 | 
30 | void Loop (uint value, out uint result)
31 | {
32 | 	for (uint j = 0; j < 4; ++j)
33 | 	{
34 | 		for (uint i = 0; i < 16; ++i)
35 | 		{
36 | 			value ^= (0x3 << i);
37 | 
38 | 			if ( ((value >> 13) & 1) == 1 )
39 | 			{
40 | 				result = 0;
41 | 				return;
42 | 			}
43 | 		}
44 | 
45 | 		++result;
46 | 	}
47 | 	result = value + 4;
48 | }
49 | 
50 | void main ()
51 | {
52 | 	uint index = gl_LocalInvocationIndex;
53 | 	uint result = 0;
54 | 
55 | 	if ( index > 0 )
56 | 	{
57 | 		result |= Hash( index * 17 );
58 | 		result |= Hash( index * 211 );
59 | 	}
60 | 	else
61 | 	{
62 | 		result |= Hash( 456 );
63 | 
64 | 		uint	temp = 1;
65 | 		Loop( result ^ (result << 4), temp );
66 | 		result |= temp;
67 | 	}
68 | 
69 | 	ssb.results[index] = result;
70 | }
71 | 
72 | #endif
73 | #endif	// SHADER
74 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/UnnamedBuffer.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 
 9 | 	self.compute.LoadSelf();
10 | }
11 | #endif
12 | //-----------------------------------------------------------------------------
13 | 
14 | 
15 | #ifdef SHADER
16 | #if SHADER & SH_COMPUTE
17 | 
18 | layout(binding=0, std430) buffer UnnamedBuffer_SSBO
19 | {
20 | 	readonly  uint	data[2];
21 | 	writeonly uint	result;
22 | };
23 | 
24 | void main ()
25 | {
26 | 	result = data[1] + data[0];
27 | }
28 | 
29 | #endif
30 | #endif	// SHADER
31 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/VecSwizzle.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 
 9 | 	self.compute.LoadSelf();
10 | }
11 | #endif
12 | //-----------------------------------------------------------------------------
13 | 
14 | 
15 | #ifdef SHADER
16 | #if SHADER & SH_COMPUTE
17 | 
18 | layout(binding=0, std430) writeonly buffer VecSwizzle_SSBO
19 | {
20 | 	 uint	results[8];
21 | } ssb;
22 | 
23 | 
24 | uint idot (uint2 a, uint2 b)
25 | {
26 | 	return a.x * b.x + a.y * b.y;
27 | }
28 | 
29 | uint idot (float2 a, float2 b)
30 | {
31 | 	return uint(a.x * b.x + a.y * b.y);
32 | }
33 | 
34 | void Foo (inout uvec2 ref)
35 | {
36 | 	ref = ref.yx | uvec2(0x1111, 0x2222);
37 | }
38 | 
39 | 
40 | void main ()
41 | {
42 | 	const uint	i = gl_LocalInvocationIndex + 1;
43 | 	const uint4	v = uint4(2,3,4,5) << i;
44 | 	uint4		w = v;
45 | 
46 | 	ssb.results[0] = idot(v.xz, v.wy);
47 | 	ssb.results[1] = v.zyx.x * 2;
48 | 
49 | 	w.wyzx.x *= 11;
50 | 	ssb.results[2] = w.w;
51 | 
52 | 	w.yz += 1;
53 | 	ssb.results[3] = w.y;
54 | 	ssb.results[4] = w.z;
55 | 
56 | 	w.yxwz.wx += 3;
57 | 	ssb.results[5] = w.z;
58 | 	ssb.results[6] = w.y;
59 | 
60 | 	// not supported in OpenCL
61 | 	//Foo( w.wx );
62 | 	//ssb.results[7] = w.w;
63 | }
64 | 
65 | #endif
66 | #endif	// SHADER
67 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'findlsb.cpp'
24 | void Create_findlsb (PipelineTemplateDescription& descr);
25 | 
26 | // From file 'atomicadd.cpp'
27 | void Create_atomicadd (PipelineTemplateDescription& descr);
28 | 
29 | // From file 'inlineall.cpp'
30 | void Create_inlineall (PipelineTemplateDescription& descr);
31 | 
32 | // From file 'unnamedbuffer.cpp'
33 | void Create_unnamedbuffer (PipelineTemplateDescription& descr);
34 | 
35 | // From file 'vecswizzle.cpp'
36 | void Create_vecswizzle (PipelineTemplateDescription& descr);
37 | 
38 | // From file 'globaltolocal.cpp'
39 | void Create_globaltolocal (PipelineTemplateDescription& descr);
40 | 
41 | // From file 'include.cpp'
42 | void Create_include (PipelineTemplateDescription& descr);
43 | 
44 | // From file 'findmsb.cpp'
45 | void Create_findmsb (PipelineTemplateDescription& descr);
46 | 
47 | }	// Pipelines
48 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compiler/Test.PipelineCompiler.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "PApp.h"
 4 | 	
 5 | extern void Test_PipelineCompiler (StringCRef device, bool debug)
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Platforms.GAPI/Compute" ) );
 8 | 
 9 | 	#ifdef GRAPHICS_API_VULKAN
10 | 	{
11 | 		PApp	app;
12 | 		app.Initialize( "VK 1.0"_GAPI, device, debug );
13 | 
14 | 		for (; app.Update();) {}
15 | 
16 | 		app.Quit();
17 | 	}
18 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
19 | 	#endif
20 | 
21 | 	#if 0 //def GRAPHICS_API_OPENGL
22 | 	{
23 | 		PApp	app;
24 | 		app.Initialize( "GL 4.5"_GAPI, device, debug );
25 | 
26 | 		for (; app.Update();) {}
27 | 
28 | 		app.Quit();
29 | 	}
30 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
31 | 	#endif
32 | 	
33 | 	#ifdef COMPUTE_API_OPENCL
34 | 	{
35 | 		PApp	app;
36 | 		app.Initialize( "CL 1.2"_GAPI, device, debug );
37 | 
38 | 		for (; app.Update();) {}
39 | 
40 | 		app.Quit();
41 | 	}
42 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
43 | 	#endif
44 | 	
45 | 	#ifdef GRAPHICS_API_SOFT
46 | 	{
47 | 		PApp	app;
48 | 		app.Initialize( "SW 1.0"_GAPI, device, debug );
49 | 
50 | 		for (; app.Update();) {}
51 | 
52 | 		app.Quit();
53 | 	}
54 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
55 | 	#endif
56 | }
57 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/BufferAlign.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 	
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | struct BufferAlign_Struct
18 | {
19 | 	int4		i4;
20 | 	float2		f2;
21 | 	bool		b1;
22 | 	uint3		u3;
23 | 	//ulong2	l2;
24 | 	//double2	d2;
25 | 	int			i1;
26 | 	bool3		b3;
27 | 	//ulong3	l3;
28 | 	//double3	d3;
29 | 	float		f1;
30 | };
31 | 
32 | layout(binding=0, std140) buffer BufferAlign_SSBO
33 | {
34 | 	readonly BufferAlign_Struct		src;
35 | 	writeonly BufferAlign_Struct	dst1;
36 | 	writeonly BufferAlign_Struct	dst2;
37 | 
38 | } ssb;
39 | 
40 | void main ()
41 | {
42 | 	ssb.dst1 = ssb.src;
43 | 
44 | 	ssb.dst2.i4 = int4( 1, -2, 3, -4 );
45 | 	ssb.dst2.f2 = float2( 3.1, 5.5 );
46 | 	ssb.dst2.b1 = true;
47 | 	ssb.dst2.u3 = uint3( 9, 8, 7 );
48 | 	//ssb.dst2.l2 = ulong2( 7823493482ul, 9189183109ul );
49 | 	//ssb.dst2.d2 = double2( 4.987, 9.1234 );
50 | 
51 | 	ssb.dst2.i1 = 0x123456;
52 | 	ssb.dst2.b3 = bool3( false, true, false );
53 | 	//ssb.dst2.d3 = double3( 5.543, 2.655e+10, -7.2345 );
54 | 	//ssb.dst2.l3 = ulong3( 8349234892ul, 172381ul, 98510910293i12ul );
55 | 	ssb.dst2.f1 = 1.4335;
56 | }
57 | 
58 | #endif
59 | #endif	// SHADER
60 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/CopyFloatImage2D.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | layout(rgba8)	readonly  uniform image2D  un_SrcImage;
18 | layout(rgba32f)	writeonly uniform image2D  un_DstImage;
19 | 
20 | void main ()
21 | {
22 | 	int2	coord = int3(gl_GlobalInvocationID).xy;
23 | 	float4	color = imageLoad( un_SrcImage, coord );
24 | 
25 | 	imageStore( un_DstImage, coord, color );
26 | }
27 | 
28 | #endif
29 | #endif	// SHADER
30 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/DynamicBuffer.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | struct DynamicBuffer_Struct
18 | {
19 | 	int2	i2;
20 | 	bool	b1;
21 | 	float2	f2;
22 | 	int3	i3;
23 | 	bool2	b2;
24 | };
25 | 
26 | void SomeFunc (DynamicBuffer_Struct arr[], const float2 f2, const int4 i4)
27 | {
28 | 	int idx = int(gl_GlobalInvocationID.x);
29 | 
30 | 	arr[idx].i2 += int2(i4.x, idx);
31 | 	arr[idx].b1 = ((idx & 1) == 0);
32 | 	arr[idx].f2 -= float2(f2);
33 | 	arr[idx].i3.xy *= 2;
34 | 	arr[idx].i3.z = ~arr[idx].i3.z;
35 | 	arr[idx].b2 = not(arr[idx].b2);
36 | }
37 | 
38 | layout(binding=0, std140) coherent buffer DynamicBuffer_SSBO
39 | {
40 | 	// static part
41 | 	float2	f2;
42 | 	int4	i4;
43 | 
44 | 	// dynamic part
45 | 	DynamicBuffer_Struct	arr[];
46 | 
47 | } ssb;
48 | 
49 | void main ()
50 | {
51 | 	SomeFunc(ssb.arr, ssb.f2, ssb.i4);
52 | }
53 | 
54 | #endif
55 | #endif	// SHADER
56 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/Image2DBilinearFilter.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | 						uniform sampler2D  un_SrcTexture;
18 | layout(rgba8) writeonly uniform image2D    un_DstImage;
19 | 
20 | void main ()
21 | {
22 | 	int2	coord	= int3(gl_GlobalInvocationID).xy;
23 | 	int2	size	= int3(gl_NumWorkGroups * gl_WorkGroupSize).xy;
24 | 	float2	texc	= (float2(coord)) / float2(size-1);
25 | 	float4	color	= texture( un_SrcTexture, texc );
26 | 
27 | 	imageStore( un_DstImage, coord, color );
28 | }
29 | 
30 | #endif
31 | #endif	// SHADER
32 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/Image2DNearestFilter.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | 						uniform sampler2D  un_SrcTexture;
18 | layout(rgba8) writeonly uniform image2D    un_DstImage;
19 | 
20 | void main ()
21 | {
22 | 	int2	coord	= int3(gl_GlobalInvocationID).xy;
23 | 	int2	size	= int3(gl_NumWorkGroups * gl_WorkGroupSize).xy;
24 | 	float2	texc	= float2(coord) / float2(size-1);
25 | 	float4	color	= texture( un_SrcTexture, texc );
26 | 
27 | 	imageStore( un_DstImage, coord, color );
28 | }
29 | 
30 | #endif
31 | #endif	// SHADER
32 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'shaderbarrier.cpp'
24 | void Create_shaderbarrier (PipelineTemplateDescription& descr);
25 | 
26 | // From file 'dynamicbuffer.cpp'
27 | void Create_dynamicbuffer (PipelineTemplateDescription& descr);
28 | 
29 | // From file 'bufferalign.cpp'
30 | void Create_bufferalign (PipelineTemplateDescription& descr);
31 | 
32 | // From file 'image2dbilinearfilter.cpp'
33 | void Create_image2dbilinearfilter (PipelineTemplateDescription& descr);
34 | 
35 | // From file 'image2dnearestfilter.cpp'
36 | void Create_image2dnearestfilter (PipelineTemplateDescription& descr);
37 | 
38 | // From file 'copyfloatimage2d.cpp'
39 | void Create_copyfloatimage2d (PipelineTemplateDescription& descr);
40 | 
41 | }	// Pipelines
42 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Compute/Test.ComputeApi.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "CApp.h"
 4 | 	
 5 | extern void Test_ComputeApi (StringCRef device, bool debug)
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Platforms.GAPI/Compute" ) );
 8 | 
 9 | 	#ifdef GRAPHICS_API_VULKAN
10 | 	{
11 | 		CApp	app;
12 | 		app.Initialize( "VK 1.0"_GAPI, device, debug );
13 | 
14 | 		for (; app.Update();) {}
15 | 
16 | 		app.Quit();
17 | 	}
18 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
19 | 	#endif
20 | 	
21 | 	// TODO: fix for 64 bit
22 | 	#if (PLATFORM_BITS == 32) and defined(GRAPHICS_API_OPENGL)
23 | 	{
24 | 		CApp	app;
25 | 		app.Initialize( "GL 4.5"_GAPI, device, debug );
26 | 
27 | 		for (; app.Update();) {}
28 | 
29 | 		app.Quit();
30 | 	}
31 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
32 | 	#endif
33 | 	
34 | 	#ifdef COMPUTE_API_OPENCL
35 | 	{
36 | 		CApp	app;
37 | 		app.Initialize( "CL 1.2"_GAPI, device, debug );
38 | 
39 | 		for (; app.Update();) {}
40 | 
41 | 		app.Quit();
42 | 	}
43 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
44 | 	#endif
45 | 	
46 | 	#ifdef GRAPHICS_API_SOFT
47 | 	{
48 | 		CApp	app;
49 | 		app.Initialize( "SW 1.0"_GAPI, device, debug );
50 | 
51 | 		for (; app.Update();) {}
52 | 
53 | 		app.Quit();
54 | 	}
55 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
56 | 	#endif
57 | }
58 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/GApp.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #pragma once
 4 | 
 5 | #include "../Common.h"
 6 | 
 7 | 
 8 | class GApp final : public StaticRefCountedObject
 9 | {
10 | // types
11 | private:
12 | 	using TestFunc_t	= bool (GApp::*) ();
13 | 	using TestQueue_t	= Queue< TestFunc_t >;
14 | 
15 | 	using ImageRange	= GpuMsg::ImageRange;
16 | 
17 | 
18 | // variables
19 | private:
20 | 	Ptr< Module >		ms;
21 | 	bool				looping		= true;
22 | 	GraphicsModuleIDs	gpuIDs;
23 | 	ComputeModuleIDs	computeIDs;
24 | 
25 | 	ModulePtr			syncManager;
26 | 	ModulePtr			gpuThread;
27 | 	ModulePtr			cmdBuilder;
28 | 	
29 | 	TestQueue_t			tests;
30 | 
31 | 
32 | // methods
33 | public:
34 | 	GApp ();
35 | 	bool Initialize (GAPI::type api, StringCRef device, bool debug);
36 | 	void Quit ();
37 | 	bool Update ();
38 | 
39 | 
40 | private:
41 | 	bool _OnWindowClosed (const OSMsg::WindowAfterDestroy &);
42 | 	bool _Draw (const ModuleMsg::Update &);
43 | 	bool _GInit (const GpuMsg::DeviceCreated &);
44 | 	bool _GDelete (const GpuMsg::DeviceBeforeDestroy &);
45 | 	
46 | // Tests
47 | private:
48 | 
49 | 	// texture
50 | 	bool _Test_Texture2DBilinearFilter ();
51 | 	bool _Test_Texture2DNearestFilter ();
52 | };
53 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/Pipelines/Texture2DBilinearFilter.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | 						uniform sampler2D  un_SrcTexture;
18 | layout(rgba8) writeonly uniform image2D    un_DstImage;
19 | 
20 | void main ()
21 | {
22 | 	int2	coord	= int3(gl_GlobalInvocationID).xy;
23 | 	int2	size	= int3(gl_NumWorkGroups * gl_WorkGroupSize).xy;
24 | 	float2	point	= (float2(coord)) / float2(size-1);
25 | 	float4	color	= texture( un_SrcTexture, point );
26 | 
27 | 	imageStore( un_DstImage, coord, color );
28 | }
29 | 
30 | #endif
31 | #endif	// SHADER
32 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/Pipelines/Texture2DNearestFilter.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ComputePipeline	self = ComputePipeline();
 6 | 
 7 | 	self.shaderFormat = EShaderFormat_GXSL_100;
 8 | 	self.compute.LoadSelf();
 9 | }
10 | #endif
11 | //-----------------------------------------------------------------------------
12 | 
13 | 
14 | #ifdef SHADER
15 | #if SHADER & SH_COMPUTE
16 | 
17 | 						uniform sampler2D  un_SrcTexture;
18 | layout(rgba8) writeonly uniform image2D    un_DstImage;
19 | 
20 | void main ()
21 | {
22 | 	int2	coord	= int3(gl_GlobalInvocationID).xy;
23 | 	int2	size	= int3(gl_NumWorkGroups * gl_WorkGroupSize).xy;
24 | 	float2	point	= float2(coord) / float2(size-1);
25 | 	float4	color	= textureOffset( un_SrcTexture, point, int2(-2,0) );
26 | 
27 | 	imageStore( un_DstImage, coord, color );
28 | }
29 | 
30 | #endif
31 | #endif	// SHADER
32 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'texture2dnearestfilter.cpp'
24 | void Create_texture2dnearestfilter (PipelineTemplateDescription& descr);
25 | 
26 | // From file 'texture2dbilinearfilter.cpp'
27 | void Create_texture2dbilinearfilter (PipelineTemplateDescription& descr);
28 | 
29 | }	// Pipelines
30 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/Pipelines/shared_types.h:
--------------------------------------------------------------------------------
1 | // This is generated file
2 | #pragma once
3 | 
4 | namespace Pipelines
5 | {
6 | }	// Pipelines
7 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Graphics/Test.GraphicsApi.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "GApp.h"
 4 | 	
 5 | extern void Test_GraphicsApi (StringCRef device, bool debug)
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Platforms.GAPI/Graphics" ) );
 8 | 
 9 | 	#if 0 //def GRAPHICS_API_OPENGL
10 | 	{
11 | 		GApp	app;
12 | 		app.Initialize( "GL 4.5"_GAPI, device, debug );
13 | 
14 | 		for (; app.Update();) {}
15 | 
16 | 		app.Quit();
17 | 	}
18 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
19 | 	#endif
20 | 	
21 | 	#ifdef GRAPHICS_API_VULKAN
22 | 	{
23 | 		GApp	app;
24 | 		app.Initialize( "VK 1.0"_GAPI, device, debug );
25 | 
26 | 		for (; app.Update();) {}
27 | 
28 | 		app.Quit();
29 | 	}
30 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
31 | 	#endif
32 | 	
33 | 	#ifdef GRAPHICS_API_SOFT
34 | 	{
35 | 		GApp	app;
36 | 		app.Initialize( "SW 1.0"_GAPI, device, debug );
37 | 
38 | 		for (; app.Update();) {}
39 | 
40 | 		app.Quit();
41 | 	}
42 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
43 | 	#endif
44 | }
45 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Common.h"
 4 | 
 5 | extern void Test_ComputeApi (StringCRef device, bool debug);
 6 | extern void Test_GraphicsApi (StringCRef device, bool debug);
 7 | extern void Test_Sharing (StringCRef device, bool debug);
 8 | extern void Test_PipelineCompiler (StringCRef device, bool debug);
 9 | extern void Test_MultiGPU (StringCRef device, bool debug);
10 | extern void Test_Window ();
11 | 
12 | 
13 | /*
14 | =================================================
15 | 	main
16 | =================================================
17 | */
18 | int main ()
19 | {
20 | 	// for example: intel HD 630, GTX 1050 Ti, ...
21 | 	// warning: some device name did not contains vendor name
22 | 	const String	device	= "";
23 | 	const bool		debug	= true;
24 | 
25 | 	Logger::GetInstance()->Open( "log", false );
26 | 	
27 | 	Test_PipelineCompiler( device, debug );
28 | 	Test_ComputeApi( device, debug );
29 | 	Test_GraphicsApi( device, debug );
30 | 	Test_Sharing( device, debug );
31 | 	//Test_MultiGPU( device, debug );
32 | 	//Test_Window();
33 | 
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/MultiGPU/Test.MultiGPU.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | /*
 3 | #include "MApp.h"
 4 | 	
 5 | extern void Test_MultiGPU (StringCRef device, bool debug)
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Platforms.GAPI/Compute" ) );
 8 | 
 9 | 	#ifdef GRAPHICS_API_VULKAN
10 | 	{
11 | 		CApp	app;
12 | 		app.Initialize( "VK 1.0"_GAPI, device );
13 | 
14 | 		for (; app.Update();) {}
15 | 
16 | 		app.Quit();
17 | 	}
18 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
19 | 	#endif
20 | 
21 | 	#ifdef GRAPHICS_API_OPENGL
22 | 	{
23 | 		CApp	app;
24 | 		app.Initialize( "GL 4.5"_GAPI, device );
25 | 
26 | 		for (; app.Update();) {}
27 | 
28 | 		app.Quit();
29 | 	}
30 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
31 | 	#endif
32 | 	
33 | 	#ifdef COMPUTE_API_OPENCL
34 | 	{
35 | 		CApp	app;
36 | 		app.Initialize( "CL 1.2"_GAPI, device );
37 | 
38 | 		for (; app.Update();) {}
39 | 
40 | 		app.Quit();
41 | 	}
42 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
43 | 	#endif
44 | 	
45 | 	#ifdef GRAPHICS_API_SOFT
46 | 	{
47 | 		CApp	app;
48 | 		app.Initialize( "SW 1.0"_GAPI, device );
49 | 
50 | 		for (; app.Update();) {}
51 | 
52 | 		app.Quit();
53 | 	}
54 | 	GetMainSystemInstance()->Send( ModuleMsg::Delete{} );
55 | 	#endif
56 | }
57 | */


--------------------------------------------------------------------------------
/EngineTests/Platforms.GAPI/Window/Test.Window.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Window1.h"
 4 | 	
 5 | extern void Test_Window ()
 6 | {
 7 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "EngineTests/Platforms.GAPI/Window" ) );
 8 | 
 9 | 	Test_WindowApp1();
10 | }
11 | 


--------------------------------------------------------------------------------
/External/README.md:
--------------------------------------------------------------------------------
1 | # External dependencies for engine
2 | All dependencies will be loaded in build time.


--------------------------------------------------------------------------------
/External/cmake/AngelScript/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.6.0)
 2 | 
 3 | project( "AngelScript_Dependencies" LANGUAGES CXX )
 4 | set_property( GLOBAL PROPERTY USE_FOLDERS ON )
 5 | 
 6 | #----------------------------------------------------------------------------------
 7 | # settings
 8 | 
 9 | set( SOURCE_PATH "${EXTERNALS_PATH}/AngelScript" )
10 | 
11 | 
12 | #----------------------------------------------------------------------------------
13 | # dependent projects
14 | 
15 | add_definitions( -DAS_USE_NAMESPACE )
16 | 
17 | add_subdirectory( "${EXTERNALS_PATH}/AngelScript/sdk/angelscript/projects/cmake" "angelscript" )
18 | 
19 | add_library( "AngelScript_Dependencies" STATIC
20 | 	"${SOURCE_PATH}/sdk/add_on/scriptstdstring/scriptstdstring.cpp"
21 | 	"${SOURCE_PATH}/sdk/add_on/scriptstdstring/scriptstdstring.h"
22 | 	"${SOURCE_PATH}/sdk/add_on/scriptstdstring/scriptstdstring_utils.cpp"
23 | )
24 | 
25 | target_include_directories( "AngelScript_Dependencies" PRIVATE "${SOURCE_PATH}/sdk/angelscript/include" )
26 | 
27 | target_link_libraries( "AngelScript_Dependencies" PUBLIC "angelscript" )
28 | 


--------------------------------------------------------------------------------
/External/cmake/DevIL/main.cpp:
--------------------------------------------------------------------------------
1 | extern int DevIL_main_dummy ()
2 | {
3 | 	// unused function to create static library
4 | 	return 0;
5 | }
6 | 


--------------------------------------------------------------------------------
/External/cmake/DirectX/dx11.cmake:
--------------------------------------------------------------------------------
1 | 
2 | find_library( D3DCOMPILER_LIBRARY D3DCompiler )
3 | 


--------------------------------------------------------------------------------
/External/cmake/download.cmake:
--------------------------------------------------------------------------------
 1 | # download sources from git repository
 2 | 
 3 | ExternalProject_Add( "External.Download"
 4 | 	# download
 5 | 	DOWNLOAD_DIR		"${EXTERNALS_PATH}"
 6 | 	GIT_REPOSITORY		https://github.com/azhirnov/ModularGraphicsFramework-Externals.git
 7 | 	GIT_TAG				27cd61aa84b085157bcc9281c6ba9c804723c145	#master
 8 | 	EXCLUDE_FROM_ALL	1
 9 | 	LOG_DOWNLOAD		1
10 | 	# update
11 | 	#UPDATE_COMMAND		""
12 | 	PATCH_COMMAND		""
13 | 	UPDATE_DISCONNECTED	1
14 | 	LOG_UPDATE			1
15 | 	# configure
16 | 	SOURCE_DIR			"${EXTERNALS_PATH}"
17 | 	CONFIGURE_COMMAND	""
18 | 	# build
19 | 	BINARY_DIR			""
20 | 	BUILD_COMMAND		""
21 | 	INSTALL_COMMAND		""
22 | 	TEST_COMMAND		""
23 | )
24 | set_property( TARGET "External.Download" PROPERTY FOLDER "External" )
25 | 


--------------------------------------------------------------------------------
/External/cmake/glslang/build_internal.cmake:
--------------------------------------------------------------------------------
1 | 
2 | add_definitions( -DAMD_EXTENSIONS -DNV_EXTENSIONS -DENABLE_HLSL )
3 | add_subdirectory( "${EXTERNALS_PATH}/glslang" "${CMAKE_BINARY_DIR}/glslang_bin" )
4 | 
5 | add_library( "glsl" INTERFACE )
6 | target_link_libraries( "glsl" INTERFACE "glslang" "HLSL" "OGLCompiler" "OSDependent" "SPIRV" "SPIRV-Tools" "SPIRV-Tools-opt" "SPVRemapper" )
7 | 


--------------------------------------------------------------------------------
/External/cmake/lz4/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.6.0)
 2 | 
 3 | project( "LZ4" LANGUAGES C )
 4 | 
 5 | set( SOURCE_PATH "${EXTERNALS_PATH}/lz4/lib" )
 6 | 
 7 | include_directories( "${SOURCE_PATH}" )
 8 | 
 9 | add_definitions( -DLZ4_DLL_EXPORT=1 )
10 | 
11 | add_library( "LZ4" STATIC
12 | 	"${SOURCE_PATH}/lz4.c"
13 | 	"${SOURCE_PATH}/lz4.h"
14 | 	"${SOURCE_PATH}/lz4frame.c"
15 | 	"${SOURCE_PATH}/lz4frame.h"
16 | 	"${SOURCE_PATH}/lz4frame_static.h"
17 | 	"${SOURCE_PATH}/lz4hc.c"
18 | 	"${SOURCE_PATH}/lz4hc.h"
19 | 	"${SOURCE_PATH}/xxhash.c"
20 | 	"${SOURCE_PATH}/xxhash.h"
21 | )
22 | 


--------------------------------------------------------------------------------
/External/cmake/miniz/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.6.0)
 2 | 
 3 | project( "MiniZ" LANGUAGES C )
 4 | 
 5 | set( SOURCE_PATH "${EXTERNALS_PATH}/miniz" )
 6 | 
 7 | include_directories( "${SOURCE_PATH}" )
 8 | 
 9 | add_library( "MiniZ" STATIC
10 | 	"${SOURCE_PATH}/miniz.c"
11 | 	"${SOURCE_PATH}/miniz.h"
12 | 	"${SOURCE_PATH}/miniz_common.h"
13 | 	"${SOURCE_PATH}/miniz_tdef.c"
14 | 	"${SOURCE_PATH}/miniz_tdef.h"
15 | 	"${SOURCE_PATH}/miniz_tinfl.c"
16 | 	"${SOURCE_PATH}/miniz_tinfl.h"
17 | 	"${SOURCE_PATH}/miniz_zip.c"
18 | 	"${SOURCE_PATH}/miniz_zip.h"
19 | )
20 | 


--------------------------------------------------------------------------------
/External/cmake/options.cmake:
--------------------------------------------------------------------------------
 1 | 
 2 | if (${ENABLE_SDL})
 3 | 	add_definitions( -DPLATFORM_SDL )
 4 | endif ()
 5 | 
 6 | if (${ENABLE_ANGELSCRIPT})
 7 | 	add_definitions( -DGX_ENABLE_ANGELSCRIPT )
 8 | endif ()
 9 | 
10 | if (${ENABLE_GLSLANG})
11 | 	add_definitions( -DGX_ENABLE_GLSLANG -DAMD_EXTENSIONS -DNV_EXTENSIONS -DENABLE_HLSL )
12 | endif ()
13 | 
14 | if (${ENABLE_FREEIMAGE})
15 | 	add_definitions( -DGX_ENABLE_FREEIMAGE )
16 | endif ()
17 | 
18 | if (${ENABLE_LODEPNG})
19 | 	add_definitions( -DGX_ENABLE_LODEPNG )
20 | endif ()
21 | 
22 | if (${ENABLE_DEVIL})
23 | 	add_definitions( -DGX_ENABLE_DEVIL )
24 | endif ()
25 | 
26 | if (${DOWNLOAD_EXTERNALS} OR EXISTS "${EXTERNALS_PATH}/glm")
27 | 	add_definitions( -DGX_ENABLE_GLM )
28 | endif ()
29 | 
30 | if (${ENABLE_LZ4})
31 | 	add_definitions( -DGX_ENABLE_LZ4 )
32 | endif ()
33 | 
34 | if (${ENABLE_MINIZ})
35 | 	add_definitions( -DGX_ENABLE_MINIZ )
36 | endif ()
37 | 
38 | if (D3DCOMPILER_LIBRARY)
39 | 	add_definitions( -DGX_ENABLE_DXCOMPILER )
40 | endif ()
41 | 


--------------------------------------------------------------------------------
/External/downloaded/AngelScript/sdk/angelscript/projects/cmake/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # this file used for configuration stage of cmake
2 | # and will be replaced when downloading external sources
3 | 


--------------------------------------------------------------------------------
/External/downloaded/SDL2/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # this file used for configuration stage of cmake
2 | # and will be replaced when downloading external sources
3 | 


--------------------------------------------------------------------------------
/External/downloaded/glslang/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | # this file used for configuration stage of cmake
2 | # and will be replaced when downloading external sources
3 | 


--------------------------------------------------------------------------------
/External/opengles/origin/gl3platform.h:
--------------------------------------------------------------------------------
 1 | #ifndef __gl3platform_h_
 2 | #define __gl3platform_h_
 3 | 
 4 | /*
 5 | ** Copyright (c) 2017 The Khronos Group Inc.
 6 | **
 7 | ** Licensed under the Apache License, Version 2.0 (the "License");
 8 | ** you may not use this file except in compliance with the License.
 9 | ** You may obtain a copy of the License at
10 | **
11 | **     http://www.apache.org/licenses/LICENSE-2.0
12 | **
13 | ** Unless required by applicable law or agreed to in writing, software
14 | ** distributed under the License is distributed on an "AS IS" BASIS,
15 | ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | ** See the License for the specific language governing permissions and
17 | ** limitations under the License.
18 | */
19 | 
20 | /* Platform-specific types and definitions for OpenGL ES 3.X  gl3.h
21 |  *
22 |  * Adopters may modify khrplatform.h and this file to suit their platform.
23 |  * Please contribute modifications back to Khronos as pull requests on the
24 |  * public github repository:
25 |  *      https://github.com/KhronosGroup/OpenGL-Registry
26 |  */
27 | 
28 | #include <KHR/khrplatform.h>
29 | 
30 | #ifndef GL_APICALL
31 | #define GL_APICALL  KHRONOS_APICALL
32 | #endif
33 | 
34 | #ifndef GL_APIENTRY
35 | #define GL_APIENTRY KHRONOS_APIENTRY
36 | #endif
37 | 
38 | #endif /* __gl3platform_h_ */
39 | 


--------------------------------------------------------------------------------
/External/vulkan/gen_vulkan_1_mir.h:
--------------------------------------------------------------------------------
 1 | // Generated header file
 2 | 
 3 | #pragma once
 4 | 
 5 | #ifndef VULKAN_MIR_H_
 6 | #define VULKAN_MIR_H_ 1
 7 | #define VK_KHR_mir_surface 1
 8 | #define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
 9 | #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
10 | typedef VkFlags VkMirSurfaceCreateFlagsKHR;
11 | struct VkMirSurfaceCreateInfoKHR { 
12 |     VkStructureType               sType;
13 |     const void*                   pNext;
14 |     VkMirSurfaceCreateFlagsKHR    flags;
15 |     MirConnection*                connection;
16 |     MirSurface*                   mirSurface;
17 | };
18 | 
19 | typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
20 | 
21 | typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
22 | 
23 | #endif
24 | 
25 | 
26 | #define VK1_MIR_FUNCTIONS( _buildFunc_ ) \
27 | 	_buildFunc_( [[nodiscard]] VkResult, vkCreateMirSurfaceKHR, ( VkInstance instance , const VkMirSurfaceCreateInfoKHR * pCreateInfo , const VkAllocationCallbacks * pAllocator , VkSurfaceKHR * pSurface ) , VK_RESULT_MAX_ENUM ) \
28 | 	_buildFunc_( VkBool32, vkGetPhysicalDeviceMirPresentationSupportKHR, ( VkPhysicalDevice physicalDevice , uint32_t queueFamilyIndex , MirConnection * connection ) , (VkBool32)(0) ) \
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/External/vulkan/gen_vulkan_1_xlib.h:
--------------------------------------------------------------------------------
 1 | // Generated header file
 2 | 
 3 | #pragma once
 4 | 
 5 | #ifndef VULKAN_XLIB_H_
 6 | #define VULKAN_XLIB_H_ 1
 7 | #define VK_KHR_xlib_surface 1
 8 | #define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
 9 | #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
10 | typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
11 | struct VkXlibSurfaceCreateInfoKHR { 
12 |     VkStructureType                sType;
13 |     const void*                    pNext;
14 |     VkXlibSurfaceCreateFlagsKHR    flags;
15 |     Display*                       dpy;
16 |     Window                         window;
17 | };
18 | 
19 | typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
20 | 
21 | typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
22 | 
23 | #endif
24 | 
25 | 
26 | #define VK1_XLIB_FUNCTIONS( _buildFunc_ ) \
27 | 	_buildFunc_( [[nodiscard]] VkResult, vkCreateXlibSurfaceKHR, ( VkInstance instance , const VkXlibSurfaceCreateInfoKHR * pCreateInfo , const VkAllocationCallbacks * pAllocator , VkSurfaceKHR * pSurface ) , VK_RESULT_MAX_ENUM ) \
28 | 	_buildFunc_( VkBool32, vkGetPhysicalDeviceXlibPresentationSupportKHR, ( VkPhysicalDevice physicalDevice , uint32_t queueFamilyIndex , Display * dpy , VisualID visualID ) , (VkBool32)(0) ) \
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 2-Clause License
 2 | 
 3 | Copyright (c) 2017-2018, Zhirnov Andrey
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | * Redistributions of source code must retain the above copyright notice, this
10 |   list of conditions and the following disclaimer.
11 | 
12 | * Redistributions in binary form must reproduce the above copyright notice,
13 |   this list of conditions and the following disclaimer in the documentation
14 |   and/or other materials provided with the distribution.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
20 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/Common.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Engine/Scene/Engine.Scene.h"
 4 | 
 5 | namespace ShaderEditor
 6 | {
 7 | 	using namespace Engine;
 8 | 	using namespace Engine::Base;
 9 | 	using namespace Engine::Platforms;
10 | 	using namespace Engine::Scene;
11 | 
12 | }	// ShaderEditor
13 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/Pipelines/Experimental.ppln:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	GraphicsPipeline	ppln = ShadertoyTemplate();
 6 | 
 7 | 	ppln.shaders.fragment.LoadSelf();
 8 | }
 9 | #endif	// ANGELSCRIPT
10 | //-----------------------------------------------------------------------------
11 | 
12 | 
13 | #ifdef SHADER
14 | #if SHADER & SH_FRAGMENT
15 | 
16 | uniform sampler2D	iChannel0;
17 | 
18 | void mainImage (out vec4 fragColor, in vec2 fragCoord)
19 | {
20 | 	vec2 uv = fragCoord.xy / iResolution.xy;
21 | 	//fragColor = vec4(uv,0.5+0.5*sin(iTime),1.0);
22 | 
23 | 	fragColor = texture( iChannel0, uv ).xxxx;
24 | }
25 | 
26 | #endif
27 | #endif	// SHADER
28 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/Pipelines/all_pipelines.h:
--------------------------------------------------------------------------------
 1 | // This is generated file
 2 | #pragma once
 3 | 
 4 | #include "Engine/Platforms/Engine.Platforms.h"
 5 | 
 6 | #ifdef GRAPHICS_API_SOFT
 7 | #include "Engine/Platforms/Soft/ShaderLang/SWLang.h"
 8 | #endif
 9 | 
10 | namespace Pipelines
11 | {
12 | 	using namespace GX_STL;
13 | 	using namespace GX_STL::GXTypes;
14 | 	using namespace GX_STL::GXMath;
15 | 
16 | 	using namespace Engine::Platforms;
17 | }
18 | 
19 | #include "shared_types.h"
20 | 
21 | namespace Pipelines
22 | {
23 | // From file 'experimental.cpp'
24 | void Create_experimental (PipelineTemplateDescription& descr);
25 | 
26 | // From file 'drawtexturedquad.cpp'
27 | void Create_drawtexturedquad (PipelineTemplateDescription& descr);
28 | 
29 | // From file 'glowballs.cpp'
30 | void Create_glowballs (PipelineTemplateDescription& descr);
31 | 
32 | // From file 'sireniandawn1.cpp'
33 | void Create_sireniandawn1 (PipelineTemplateDescription& descr);
34 | 
35 | // From file 'sireniandawn2.cpp'
36 | void Create_sireniandawn2 (PipelineTemplateDescription& descr);
37 | 
38 | // From file 'skyline.cpp'
39 | void Create_skyline (PipelineTemplateDescription& descr);
40 | 
41 | // From file 'voronnoirecursion.cpp'
42 | void Create_voronnoirecursion (PipelineTemplateDescription& descr);
43 | 
44 | }	// Pipelines
45 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/README.md:
--------------------------------------------------------------------------------
1 | # Shader Editor project


--------------------------------------------------------------------------------
/Projects/ShaderEditor/ShaderEditorApp.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "Renderer.h"
 4 | 
 5 | namespace ShaderEditor
 6 | {
 7 | 
 8 | 	//
 9 | 	// Shader Editor App
10 | 	//
11 | 
12 | 	class ShaderEditorApp final : public StaticRefCountedObject
13 | 	{
14 | 	// types
15 | 	private:
16 | 		using Samples_t	= Array< Function< void (Renderer&) > >;
17 | 
18 | 
19 | 	// variables
20 | 	private:
21 | 		ModulePtr		_camera;
22 | 		ModulePtr		_surface;
23 | 
24 | 		Renderer		_renderer;
25 | 
26 | 		Samples_t		_samples;
27 | 		usize			_currSample;
28 | 		usize			_nextSample;
29 | 
30 | 		bool			_looping;
31 | 		const bool		_vrMode;
32 | 
33 | 	
34 | 	// methods
35 | 	public:
36 | 		ShaderEditorApp ();
37 | 
38 | 		bool Initialize (GAPI::type api);
39 | 		void Quit ();
40 | 		bool Update ();
41 | 
42 | 	private:
43 | 		bool _OnWindowClosed (const OSMsg::WindowBeforeDestroy &);
44 | 		bool _Init (const ModuleMsg::Compose &);
45 | 		bool _GInit (const GpuMsg::DeviceCreated &);
46 | 		bool _Draw (const SceneMsg::CameraRequestUpdate &);
47 | 
48 | 		void _OnKey (const ModuleMsg::InputKey &);
49 | 
50 | 		void _InitSamples ();
51 | 	};
52 | 
53 | }	// ShaderEditor
54 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/images/vfs_images_main.cpp:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "vfs_images_main.h"
 4 | #include "Core/STL/Containers/HashMap.h"
 5 | 
 6 | namespace vfs_images
 7 | {
 8 | 
 9 | 	extern void VFS_images_greynoise (OUT BinaryArray &data);
10 | 
11 | 	void (* GetBuiltinFileLoader (StringCRef filename)) (OUT BinaryArray &)
12 | 	{
13 | 		static const HashMap< String, void (*) (OUT BinaryArray &) > vfs = {
14 | 			{ "greynoise.png", &VFS_images_greynoise }		};
15 | 
16 | 		usize idx = UMax;
17 | 		if ( vfs.FindIndex( filename, OUT idx ) ) {
18 | 			return vfs[idx].second;
19 | 		}
20 | 		return null;
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/images/vfs_images_main.h:
--------------------------------------------------------------------------------
 1 | // This is generated file, don't change anything!
 2 | 
 3 | #include "Core/STL/Containers/StringRef.h"
 4 | #include "Core/STL/Containers/Array.h"
 5 | 
 6 | namespace vfs_images
 7 | {
 8 | 	using namespace GX_STL;
 9 | 	using namespace GX_STL::GXTypes;
10 | 
11 | 	void (* GetBuiltinFileLoader (StringCRef filename)) (OUT BinaryArray &);
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/Projects/ShaderEditor/res/greynoise.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Projects/ShaderEditor/res/greynoise.png


--------------------------------------------------------------------------------
/Projects/ShaderEditor/res/old/img.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Projects/ShaderEditor/res/old/img.png


--------------------------------------------------------------------------------
/Projects/ShaderEditor/res/old/img1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/azhirnov/ModularGraphicsFramework/348be601f1991f102defa0c99250529f5e44c4d3/Projects/ShaderEditor/res/old/img1.png


--------------------------------------------------------------------------------
/Projects/ShaderEditor/resources.as:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef ANGELSCRIPT
 3 | void main ()
 4 | {
 5 | 	ResourcePacker	rpack;
 6 | 
 7 | 	// setup pipeline compiler
 8 | 	{
 9 | 		Pipeline_ConverterConfig	cfg;
10 | 		
11 | 		cfg.searchForSharedTypes	= true;
12 | 		cfg.addPaddingToStructs		= true;
13 | 		cfg.optimizeSource			= false;
14 | 		cfg.optimizeBindings		= true;
15 | 		cfg.minimalRebuild			= true;
16 | 		cfg.nameSpace				= "Pipelines";
17 | 		cfg.targets					|= EShaderFormat_GLSL_450;
18 | 		cfg.targets					|= EShaderFormat_VK_100_SPIRV;
19 | 		//cfg.targets					|= EShaderFormat_CL_120;
20 | 		cfg.targets					|= EShaderFormat_Soft_100_Exe;
21 | 
22 | 		rpack.SetConfig( cfg );
23 | 	}
24 | 
25 | 	// convert compute pipelines
26 | 	{
27 | 		// graphics pipeline
28 | 		rpack.AddPipelineTemplate( "Pipelines/ShaderToy.tmpl", "ShadertoyTemplate" );
29 | 		
30 | 		// compute pipeline
31 | 		rpack.AddPipelineTemplate( "Pipelines/ShaderToyComp.tmpl", "ShadertoyCompTemplate" );
32 | 
33 | 		rpack.AddAllPipelines( "Pipelines" );
34 | 		rpack.ConvertPipelines( "Pipelines" );
35 | 	}
36 | 
37 | 	// convert images
38 | 	{
39 | 		ImagePacker	imgpack;
40 | 
41 | 		imgpack.SetCPPVFS( "images" );
42 | 		imgpack.PackTexturesInFolder( "res" );
43 | 	}
44 | }
45 | #endif	// ANGELSCRIPT
46 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Modular Graphics Framework
 2 | At first it was experimental port of my engine to another architecture, and now I make it as may primary engine.
 3 | 
 4 | Features:
 5 | - Event driven architecture.
 6 | - Many graphics APIs without recompilation.
 7 | - Low level abstraction of API: Image, Buffer, CommandBuffer, Pipeline and other.
 8 | - Run many graphics API at one time for debugging - to see different behavior (WIP).
 9 | - High level abstraction: Scene, RenderTechnique and other (WIP).
10 | - Shader compiler - one shader for all platforms.
11 | - Procedural generation (WIP).
12 | - Virtual Reality (Emulator, Oculus - WIP).
13 | 
14 | Supported APIs:
15 | - Vulkan 1.0 - 1.1 (primary)
16 | - OpenGL 4.4 - 4.6
17 | - DirectX 11 (WIP)
18 | - OpenCL 1.1 - 2.0
19 | - Software renderer
20 | - OpenGL ES 3.0 - 3.2 (WIP)
21 | 
22 | Supported OS:
23 | - Windows
24 | - Linux (WIP)
25 | - Android (WIP)
26 | 
27 | Supported compilers:
28 | - VS 2017 (tested on 15.6.7)
29 | - MinGW (tested on 7.2.0)
30 | 
31 | Optional dependencies:
32 | - glslang, SDL2, GLM and other
33 | 


--------------------------------------------------------------------------------
/Utils/CMake/Proj/GenUtils.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "PipelineBuilding.h"
 4 | 
 5 | CMakeBuilderPtr  GenUtils (Ptr<CMakeBuilder> core)
 6 | {
 7 | #ifdef ENABLE_UTILS
 8 | 
 9 | 	CMakeBuilderPtr		builder{ new CMakeBuilder{ "Utils", "Utils" } };
10 | 	
11 | 	builder->InheritCompilers( core );
12 | 	builder->InheritIncludeDirectories( core );
13 | 	builder->SetSecondary();
14 | 	
15 | 	auto	core_stl = core->GetProject( "Core.STL" );
16 | 
17 | 
18 | 	auto	util_cmake = builder->AddExecutable( "Utils.CMake", "CMake" );
19 | 	{
20 | 		util_cmake->EnableIf( "NOT DEFINED ANDROID" );
21 | 		util_cmake->AddFoldersRecursive( "" );
22 | 		util_cmake->ProjFolder( "Utils" );
23 | 		util_cmake->LinkLibrary( core_stl );
24 | 	}
25 | 	//----------------------------------------------------------------------------
26 | 
27 | 	
28 | 	builder->Save();
29 | 	return builder;
30 | 
31 | #else
32 | 	return null;
33 | 
34 | #endif	// ENABLE_UTILS
35 | }
36 | 


--------------------------------------------------------------------------------
/Utils/CMake/Proj/Main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c)  Zhirnov Andrey. For more information see 'LICENSE.txt'
 2 | 
 3 | #include "PipelineBuilding.h"
 4 | 
 5 | 
 6 | int main ()
 7 | {
 8 | 	CHECK( OS::FileSystem::FindAndSetCurrentDir( "Utils/CMake/Builder", 5 ) );
 9 | 	CHECK( OS::FileSystem::SetCurrentDirectory( "../../.." ) );
10 | 	
11 | 	CMakeBuilder	builder{ "", "ModularGraphicsFramework" };
12 | 
13 | 	CMakeBuilderPtr compilers		= GenCompilers();
14 | 	compilers->Save( "Core/compilers.cmake" );
15 | 
16 | 	CMakeBuilderPtr	core			= GenCore( compilers.ptr() );
17 | 	CMakeBuilderPtr	engine			= GenEngine( core.ptr() );
18 | 	CMakeBuilderPtr	shader_editor	= GenShaderEditor( engine.ptr() );
19 | 	CMakeBuilderPtr	utils			= GenUtils( core.ptr() );
20 | 	
21 | 
22 | 	builder.IncludeExternal( "Core/compilers.cmake" );
23 | 	builder.AddSource(R"#(
24 | set( MAIN_BINARY_DIR "${CMAKE_BINARY_DIR}/bin" CACHE INTERNAL "" FORCE )
25 | set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${MAIN_BINARY_DIR}" )
26 | set( CMAKE_LIBRARY_OUTPUT_DIRECTORY "${MAIN_BINARY_DIR}" )
27 | set( CMAKE_RUNTIME_OUTPUT_DIRECTORY "${MAIN_BINARY_DIR}" )
28 | )#");
29 | 
30 | #	ifdef ENABLE_EXTERNALS
31 | 	builder.AddExternal( "External/cmake" )->AddSource( "include( \"External/cmake/options.cmake\" )" );
32 | #	endif
33 | 	
34 | 	builder.AddExternal( core.ptr() );
35 | 	builder.AddExternal( engine.ptr() );
36 | 	builder.AddExternal( shader_editor.ptr() );
37 | 	builder.AddExternal( utils.ptr() );
38 | 
39 | 	builder.Save();
40 | 
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------