Implementações iniciais do pipeline

includes/pipeline/compiler.hpp

@@ -0,0 +1,45 @@
+#ifndef XNA_PIPELINE_COMPILER_HPP
+#define XNA_PIPELINE_COMPILER_HPP
+
+#include "xna/default.hpp"
+#include "xna/csharp/stream.hpp"
+#include "pipeline-enums.hpp"
+#include "default.hpp"
+#include <stack>
+
+namespace xna {
+	//Provides methods for writing compiled binary format.
+	class ContentCompiler : public std::enable_shared_from_this<ContentCompiler> {
+	public:
+		ContentCompiler();
+
+		//Retrieves the worker writer for the specified type
+		P_ContentTypeWriter GetTypeWriter(Type const& type, std::vector<P_Type> dependencies);
+
+	private:
+		void Compile(
+			P_Stream const& output,
+			Object& value,
+			TargetPlatform targetPlatform,
+			GraphicsProfile targetProfile,
+			bool compressContent,
+			String const& rootDirectory,
+			String const& referenceRelocationPath);
+
+		void AddTypeWriter(P_ContentTypeWriter const& writer);
+
+		bool ShouldCompressContent(TargetPlatform targetPlatform, Object& value) {
+			return false;
+		}
+
+	private:
+		using TypeList = std::vector<P_Type>;
+
+		std::map<HashValue, P_ContentTypeWriter> writerInstances;
+		std::map<HashValue, TypeList> writerDependecies;
+		std::stack<P_ContentTypeWriter> initializeContext;
+		P_ContentTypeWriterFactory typeWriterFactory;
+	};
+}
+
+#endif

includes/pipeline/default.hpp

@@ -0,0 +1,14 @@
+#ifndef XNA_PIPELINE_DEFAULT_HPP
+#define XNA_PIPELINE_DEFAULT_HPP
+
+#include "xna/default.hpp"
+
+namespace xna {
+	class ContentTypeWriter;
+	class ContentTypeWriterFactory;
+
+	using P_ContentTypeWriter = sptr<ContentTypeWriter>;
+	using P_ContentTypeWriterFactory = sptr<ContentTypeWriterFactory>;
+}
+
+#endif

includes/pipeline/enums.hpp

@@ -0,0 +1,11 @@
+#ifndef XNA_PIPELINE_ENUMS_HPP
+#define XNA_PIPELINE_ENUMS_HPP
+
+namespace xna {
+    enum class TargetPlatform
+    {
+        Windows,
+    };
+}
+
+#endif

includes/pipeline/pipeline.hpp

@@ -0,0 +1,10 @@
+#ifndef XNA_PIPELINE_PIPELINE_HPP
+#define XNA_PIPELINE_PIPELINE_HPP
+
+namespace xna {
+	class Pipeline {
+
+	};
+}
+
+#endif

includes/pipeline/writer.hpp

@@ -0,0 +1,286 @@
+#ifndef XNA_PIPELINE_WRITER_HPP
+#define XNA_PIPELINE_WRITER_HPP
+
+#include "xna/common/color.hpp"
+#include "xna/common/numerics.hpp"
+#include "xna/csharp/binary.hpp"
+#include "xna/csharp/type.hpp"
+#include "xna/default.hpp"
+#include "default.hpp"
+#include "enums.hpp"
+#include <queue>
+
+namespace xna {
+    //Provides an implementation for many of the ContentCompiler methods including compilation, state tracking for shared resources and creation of the header type manifest.
+    class ContentTypeWriter {
+    public:
+        //Gets the assembly qualified name of the runtime loader for this type.
+        virtual String GetRuntimeReader(TargetPlatform targetPlatform) { return String(); }
+        //Gets a format version number for this type.
+        virtual Int TypeVersion() const { return 0; }
+        //Compiles an object into binary format.
+        virtual void Write(ContentWriter& output, Object& value) {}
+        //Determines if deserialization into an existing object is possible.
+        virtual bool CanDeserializeIntoExistingObject() const { return false; }
+
+    protected:
+        ContentTypeWriter(P_Type const& targetType) : targetType(targetType) {}
+
+    private:
+        P_Type targetType{ nullptr };
+    };
+
+    //Provides a generic implementation of ContentTypeWriter methods and properties for compiling a specific managed type into a binary format.
+    template <class T>
+    class ContentTypeWriter_T : public ContentTypeWriter {
+    public:
+        //Compiles a strongly typed object into binary format.
+        virtual void Write(ContentWriter& output, T& value) {}
+
+    protected:
+        ContentTypeWriter_T() : ContentTypeWriter(typeof<T>()) {}
+    };
+
+    template <class T>
+    class BuiltinTypeWriter : public ContentTypeWriter_T<T> {
+        String GetRuntimeReader(TargetPlatform targetPlatform) override {
+            String name = typeid(T).name();
+
+            switch (targetPlatform)
+            {
+            case xna::TargetPlatform::Windows:
+                name.append("::Windows");
+                break;
+            default:
+                break;
+            }
+
+            return name;
+        }
+    };
+
+    template <class T>
+    class ExternalReference {
+    public:
+        String FileName() const;
+    };
+
+    //Provides an implementation for many of the ContentCompiler methods including compilation, state tracking for shared resources and creation of the header type manifest.
+    class ContentWriter : public BinaryWriter {
+    public:
+        ContentWriter(
+            P_ContentCompiler& compiler,
+            P_Stream const& output,
+            TargetPlatform targetPlatform,
+            GraphicsProfile targetProfile,
+            bool compressContent,
+            String const& rootDirectory,
+            String const& referenceRelocationPath
+        );
+
+        //Gets the content build target platform.
+        constexpr TargetPlatform Target() const { return targetPlatform; }
+        //Gets or sets the target graphics profile.
+        constexpr GraphicsProfile TargetProfile() const { return targetProfile; }
+
+        //Writes a single object preceded by a type identifier to the output binary.
+        template <class T> void WriteObject(T& value);
+        //Writes a single object to the output binary, using the specified type hint and writer worker.
+        template <class T> void WriteObject(T& value, ContentTypeWriter& writer);
+        //Writes a single object to the output binary as an instance of the specified type.
+        template <class T> void WriteRawObject(T& value);
+        //Writes a single object to the output binary using the specified writer worker.
+        template <class T> void WriteRawObject(T& value, ContentTypeWriter& typeWriter);
+        //Adds a shared reference to the output binary and records the object to be serialized later.
+        template <class T> void WriteSharedResource(T& value);
+        //Writes the name of an external file to the output binary.
+        template <class T> void WriteExternalReference(ExternalReference<T>& reference);
+
+        using BinaryWriter::Write;
+
+        //Writes a Vector2 value.
+        void Write(Vector2 const& value);
+        //Writes a Vector3 value.
+        void Write(Vector3 const& value);
+        //Writes a Vector4 value.
+        void Write(Vector4 const& value);
+        //Writes a Matrix value.
+        void Write(Matrix const& value);
+        //Writes a Quaternion value.
+        void Write(Quaternion const& value);
+        //Writes a Color value.
+        void Write(Color const& value);
+
+        inline void FlushOutput() {
+            WriteSharedResources();
+            WriteHeader();
+            WriteFinalOutput();
+        }
+
+    private:
+        template <class T> void InvokeWriter(T& value, ContentTypeWriter& writer);
+        P_ContentTypeWriter GetTypeWriter(Type const& type, Int& typeIndex);
+        void WriteSharedResources();
+        void WriteHeader();
+        void WriteFinalOutput();
+        void WriteUncompressedOutput();
+        void WriteCompressedOutput();
+        void WriteVersionNumber(Ushort version);
+
+    private:
+        P_ContentCompiler compiler{ nullptr };
+        TargetPlatform targetPlatform{ TargetPlatform::Windows };
+        GraphicsProfile targetProfile{ GraphicsProfile::HiDef };
+        bool compressContent{ false };
+        String rootDirectory;
+        String referenceRelocationPath;
+        P_Stream finalOutput{ nullptr };
+        P_MemoryStream headerData{ nullptr };
+        P_MemoryStream contentData{ nullptr };
+        std::vector<P_ContentTypeWriter> typeWriters;
+        std::map<Object, Int> sharedResourceNames;
+        std::queue<Object> sharedResources;
+        std::map<HashValue, Int> typeTable;
+
+    private:
+        static constexpr Ushort XnbVersion = 5;
+        static constexpr Ushort XnbCompressedVersion = 32773;
+        static constexpr Ushort XnbVersionProfileMask = 32512;
+        static constexpr Int XnbVersionProfileShift = 8;
+        static constexpr Int XnbVersionOffset = 4;
+        static constexpr Int XnbFileSizeOffset = 6;
+        static constexpr Int XnbPrologueSize = 10;
+        inline static const String FilenameExt = ".xnb";
+    };
+
+    template <class T>
+    class TypeHandlerFactory {
+
+    };
+
+    class ContentTypeWriterFactory : public TypeHandlerFactory<ContentTypeWriter> {
+    public:
+        std::vector<P_ContentTypeWriter> Initialize() const {
+            std::vector<P_ContentTypeWriter> writers;
+
+            return writers;
+        }
+    };
+
+    //
+    // ContentTypeWriter
+    //
+
+    template <class T>
+    void ContentWriter::WriteObject(T& value) {
+        if constexpr (XnaHelper::IsSmartPoint<T>()) {
+            if (value == nullptr) {
+                Exception::Throw(Exception::ARGUMENT_IS_NULL);
+            }
+        }
+
+        const auto type = typeof<T>();
+        Int _;
+        auto typeWriter = GetTypeWriter(*type, _);
+
+        InvokeWriter<T>(value, *typeWriter);
+    }
+
+    template <class T>
+    void ContentWriter::WriteObject(T& value, ContentTypeWriter& writer) {
+        auto contentTypeWriter = reinterpret_cast<ContentTypeWriter_T<T>*>(&writer);
+
+        if (contentTypeWriter) {
+            contentTypeWriter->Write(*this, value);
+        }
+        else {
+            Object _value = value;
+            writer.Write(*this, _value);
+        }
+    }
+
+    template <class T>
+    void ContentWriter::WriteRawObject(T& value) {
+        if constexpr (XnaHelper::IsSmartPoint<T>()) {
+            if (value == nullptr) {
+                Exception::Throw(Exception::ARGUMENT_IS_NULL);
+            }
+        }
+
+        const auto type = typeof<T>();
+        Int _;
+        auto typeWriter = GetTypeWriter(*type, _);
+
+        InvokeWriter<T>(value, *typeWriter);
+    }
+
+    template <class T>
+    void ContentWriter::WriteRawObject(T& value, ContentTypeWriter& typeWriter) {
+        Exception::ThrowTIsNull(value);
+
+        InvokeWriter<T>(value, typeWriter);
+    }
+
+
+    template <class T>
+    void ContentWriter::WriteSharedResource(T& value) {
+        if constexpr (XnaHelper::IsSmartPoint<T>()) {
+            if (value == nullptr)
+                Write7BitEncodedInt(0);
+        }
+        else {
+            Int num;
+            Object obj = value;
+
+            if (!sharedResourceNames.contains(value)) {
+                num = sharedResourceNames.size() + 1;
+                sharedResourceNames.emplace(obj, num);
+                sharedResources.push(obj);
+            }
+            else {
+                num = sharedResourceNames[value];
+            }
+
+            Write7BitEncodedInt(num);
+        }
+    }
+
+
+    template <class T>
+    void ContentWriter::WriteExternalReference(ExternalReference<T>& reference) {
+        const auto& filename1 = reference.FileName();
+
+        if (filename1.empty()) {
+            Write("");
+        }
+        else {
+            String filename2;
+
+            if (filename1.ends_with(FilenameExt))
+                filename2 = filename1.substr(0, filename1.size() - FilenameExt.size());
+            else
+                Exception::Throw(Exception::INVALID_OPERATION);
+
+            if (!filename2.starts_with(rootDirectory))
+                Exception::Throw(Exception::INVALID_OPERATION);
+
+
+            Exception::Throw(Exception::NOT_IMPLEMENTED);
+        }
+    }
+
+    template <class T>
+    void ContentWriter::InvokeWriter(T& value, ContentTypeWriter& writer) {
+        auto contentTypeWriter = reinterpret_cast<ContentTypeWriter_T<T>*>(&writer);
+
+        if (contentTypeWriter) {
+            contentTypeWriter->Write(*this, value);
+        }
+        else {
+            Object obj = value;
+            writer.Write(*this, obj);
+        }
+    }
+}
+
+#endif

includes/xna/default.hpp

@@ -104,6 +104,12 @@ namespace xna {
 		return std::make_unique<_Ty>(std::forward<_Types>(_Args)...);
 	}
 
+	//
+	// Hash value
+	//
+
+	using HashValue = size_t;
+
 	//
 	// Forward
 	//
@@ -199,15 +205,16 @@ namespace xna {
 	using P_DepthStencilState = sptr<DepthStencilState>;
 	using P_GraphicsAdapter = sptr<GraphicsAdapter>;
 	using P_GraphicsDevice = sptr<GraphicsDevice>;
-	using P_RasterizerState = sptr<RasterizerState>;
+	using P_FileStream = sptr<FileStream>;
+	using P_MemoryStream = sptr<MemoryStream>;
 	using P_PresentationParameters = sptr<PresentationParameters>;
+	using P_RenderTarget2D = sptr<RenderTarget2D>;
 	using P_SamplerStateCollection = sptr<SamplerStateCollection>;
 	using P_Stream = sptr<Stream>;
-	using P_MemoryStream = sptr<MemoryStream>;
-	using P_FileStream = sptr<FileStream>;
+	using P_RasterizerState = sptr<RasterizerState>;
+	using P_Type = sptr<Type>;
 	using P_Texture = sptr<Texture>;
 	using P_Texture2D = sptr<Texture2D>;
-	using P_RenderTarget2D = sptr<RenderTarget2D>;
 }
 
 

sources/pipeline/CMakeLists.txt

@@ -4,13 +4,12 @@
 
 # Add source to this project's executable.
 add_library (Xn65Pipeline STATIC 
-"discard.cpp"
+"writer.cpp"
+"compiler.cpp"
 )
 
 if (CMAKE_VERSION VERSION_GREATER 3.12)
   set_property(TARGET Xn65Pipeline PROPERTY CXX_STANDARD 20)
 endif()
 
-find_package(directxtk CONFIG REQUIRED)
-
 #target_link_libraries(Xn65Pipeline)

sources/pipeline/compiler.cpp

@@ -0,0 +1,38 @@
+#include "pipeline/compiler.hpp"
+#include "pipeline/writer.hpp"
+
+namespace xna {
+	ContentCompiler::ContentCompiler() {
+		const auto writers = typeWriterFactory->Initialize();
+
+		for (auto& writer : writers)
+			AddTypeWriter(writer);
+
+		for (auto& dic : writerInstances) {
+			auto& writer = dic.second;
+			AddTypeWriter(writer);
+		}
+	}
+
+	void ContentCompiler::Compile(
+		P_Stream const& output,
+		Object& value,
+		TargetPlatform targetPlatform,
+		GraphicsProfile targetProfile,
+		bool compressContent,
+		String const& rootDirectory,
+		String const& referenceRelocationPath) {
+		if (compressContent)
+			compressContent = ShouldCompressContent(targetPlatform, value);
+
+		auto _this = shared_from_this();
+
+		auto contentWriter = unew<ContentWriter>(
+			_this, output, targetPlatform,
+			targetProfile, compressContent,
+			rootDirectory, referenceRelocationPath);
+
+		contentWriter->WriteObject(value);
+		contentWriter->FlushOutput();
+	}
+}

sources/pipeline/writer.cpp

@@ -0,0 +1,171 @@
+#include "pipeline/writer.hpp"
+#include "pipeline/compiler.hpp"
+
+namespace xna {
+
+    //
+    // ContentWriter
+    //
+
+    ContentWriter::ContentWriter(
+        P_ContentCompiler& compiler,
+        P_Stream const& output,
+        TargetPlatform targetPlatform,
+        GraphicsProfile targetProfile,
+        bool compressContent,
+        String const& rootDirectory,
+        String const& referenceRelocationPath
+    ) : compiler(compiler),
+        targetPlatform(targetPlatform),
+        targetProfile(targetProfile),
+        compressContent(compressContent),
+        rootDirectory(rootDirectory),
+        referenceRelocationPath(referenceRelocationPath),
+        finalOutput(output)
+    {
+        headerData = snew<MemoryStream>();
+        contentData = snew<MemoryStream>();
+        OutStream = reinterpret_pointer_cast<Stream>(contentData);
+    }
+
+    P_ContentTypeWriter ContentWriter::GetTypeWriter(Type const& type, Int& typeIndex) {
+        const auto& hash = type.GetHashCode();
+
+        if (typeTable.contains(hash)) {
+            typeIndex = typeTable[hash];
+            return typeWriters[typeIndex];
+        }
+
+        std::vector<P_Type> dependecies;
+        auto typeWriter = compiler->GetTypeWriter(type, dependecies);
+        typeIndex = typeWriters.size();
+
+        typeWriters.push_back(typeWriter);
+        typeTable.emplace(type.GetHashCode(), typeIndex);
+
+        for (size_t i = 0; i < dependecies.size(); ++i) {
+            const auto& type1 = dependecies[i];
+
+            if (type1 != typeof<std::any>())
+            {
+                Int _;
+                GetTypeWriter(*type1, _);
+            }
+        }
+
+        return typeWriter;
+    }
+
+    void ContentWriter::WriteSharedResources() {
+        while (sharedResources.size() > 0) {
+            sharedResources.pop();
+            auto& res = sharedResources.front();
+            WriteObject<std::any>(res);
+        }
+    }
+
+    void ContentWriter::WriteHeader() {
+        OutStream = reinterpret_pointer_cast<Stream>(headerData);
+        Write7BitEncodedInt(static_cast<Int>(typeWriters.size()));
+
+        for (size_t i = 0; i < typeWriters.size(); ++i) {
+            auto& typeWriter = typeWriters[i];
+
+            Write(typeWriter->GetRuntimeReader(targetPlatform));
+            Write(typeWriter->TypeVersion());
+        }
+
+        Write7BitEncodedInt(static_cast<Int>(sharedResourceNames.size()));
+    }
+
+    void ContentWriter::WriteFinalOutput() {
+        OutStream = finalOutput;
+
+        Write((Byte)88);
+        Write((Byte)78);
+        Write((Byte)66);
+
+        if (targetPlatform == TargetPlatform::Windows)
+            Write((Byte)119);
+        else
+            Exception::Throw(Exception::NOT_IMPLEMENTED);
+
+        if (compressContent)
+            WriteCompressedOutput();
+        else
+            WriteUncompressedOutput();
+    }
+
+    void ContentWriter::WriteUncompressedOutput() {
+        WriteVersionNumber((Ushort)5);
+
+        const auto length1 = static_cast<Int>(headerData->Length());
+        const auto length2 = static_cast<Int>(contentData->Length());
+
+        Write(10 + length1 + length2);
+
+        OutStream->Write(headerData->_buffer, 0, length1);
+        OutStream->Write(contentData->_buffer, 0, length2);
+    }
+
+    void ContentWriter::WriteCompressedOutput() {
+        Exception::Throw(Exception::NOT_IMPLEMENTED);
+    }
+
+    void ContentWriter::WriteVersionNumber(Ushort version) {
+        version |= static_cast<Ushort>(static_cast<Int>(targetProfile) << 8 & 32512);
+        Write(version);
+    }
+
+    void ContentWriter::Write(Vector2 const& value) {
+        Write(value.X);
+        Write(value.Y);
+    }
+
+    void ContentWriter::Write(Vector3 const& value) {
+        Write(value.X);
+        Write(value.Y);
+        Write(value.Z);
+    }
+
+    void ContentWriter::Write(Vector4 const& value) {
+        Write(value.X);
+        Write(value.Y);
+        Write(value.Z);
+        Write(value.W);
+    }
+
+    void ContentWriter::Write(Matrix const& value) {
+        Write(value.M11);
+        Write(value.M12);
+        Write(value.M13);
+        Write(value.M14);
+        Write(value.M21);
+        Write(value.M22);
+        Write(value.M23);
+        Write(value.M24);
+        Write(value.M31);
+        Write(value.M32);
+        Write(value.M33);
+        Write(value.M34);
+        Write(value.M41);
+        Write(value.M42);
+        Write(value.M43);
+        Write(value.M44);
+    }
+
+    void ContentWriter::Write(Quaternion const& value) {
+        Write(value.X);
+        Write(value.Y);
+        Write(value.Z);
+        Write(value.W);
+    }
+
+    void ContentWriter::Write(Color const& value) {
+        Write(value.PackedValue());
+    }
+
+    //
+    //
+    //    
+}