conflict fix

Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com>

Code/Framework/AzFramework/AzFramework/Process/ProcessCommunicatorTracePrinter.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "ProcessCommunicatorTracePrinter.h"
+
+
+ProcessCommunicatorTracePrinter::ProcessCommunicatorTracePrinter(AzFramework::ProcessCommunicator* communicator, const char* window) :
+    m_communicator(communicator),
+    m_window(window)
+{
+    m_stringBeingConcatenated.reserve(1024);
+}
+
+ProcessCommunicatorTracePrinter::~ProcessCommunicatorTracePrinter()
+{
+    // flush stdout
+    WriteCurrentString(false);
+    
+    // flush stderr
+    WriteCurrentString(true);
+}
+
+void ProcessCommunicatorTracePrinter::Pump()
+{
+    if (m_communicator->IsValid())
+    {
+        // Don't call readOutput unless there is output or else it will block...
+        while (m_communicator->PeekOutput())
+        {
+            AZ::u32 readSize = m_communicator->ReadOutput(m_streamBuffer, AZ_ARRAY_SIZE(m_streamBuffer));
+            ParseDataBuffer(readSize, false);
+        }
+        while (m_communicator->PeekError())
+        {
+            AZ::u32 readSize = m_communicator->ReadError(m_streamBuffer, AZ_ARRAY_SIZE(m_streamBuffer));
+            ParseDataBuffer(readSize, true);
+        }
+    }
+}
+
+void ProcessCommunicatorTracePrinter::ParseDataBuffer(AZ::u32 readSize, bool isFromStdErr)
+{
+    if (readSize > AZ_ARRAY_SIZE(m_streamBuffer))
+    {
+        AZ_ErrorOnce("ERROR", false, "Programmer bug:  Read size is overflowing in traceprintf communicator.");
+        return;
+    }
+
+    // we cannot write the string to the same buffer, as stdError and stdOut are different streams and could
+    // have different cutting points as buffers empty.
+    AZStd::string& bufferToUse = isFromStdErr ? m_errorStringBeingConcatenated : m_stringBeingConcatenated;
+
+    for (size_t pos = 0; pos < readSize; ++pos)
+    {
+        if ((m_streamBuffer[pos] == '\n') || (m_streamBuffer[pos] == '\r'))
+        {
+            WriteCurrentString(isFromStdErr);
+        }
+        else
+        {
+            bufferToUse.push_back(m_streamBuffer[pos]);
+        }
+    }
+}
+
+void ProcessCommunicatorTracePrinter::WriteCurrentString(bool isFromStdErr)
+{
+    AZStd::string& bufferToUse = isFromStdErr ? m_errorStringBeingConcatenated : m_stringBeingConcatenated;
+
+    if (!bufferToUse.empty())
+    {
+        if (isFromStdErr)
+        {
+            AZ_Error(m_window.c_str(), false, "%s", bufferToUse.c_str());
+        }
+        else
+        {
+            AZ_TracePrintf(m_window.c_str(), "%s", bufferToUse.c_str());
+        }
+        bufferToUse.clear();
+    }
+}

Code/Framework/AzFramework/AzFramework/Process/ProcessCommunicatorTracePrinter.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzFramework/Process/ProcessCommunicator.h>
+
+//! ProcessCommunicatorTracePrinter listens to stderr and stdout of a running process and writes its output to the AZ_Trace system
+//! Importantly, it does not do any blocking operations.
+class ProcessCommunicatorTracePrinter
+{
+public:
+    ProcessCommunicatorTracePrinter(AzFramework::ProcessCommunicator* communicator, const char* window);
+    ~ProcessCommunicatorTracePrinter();
+
+    //! Call this periodically to drain the buffers and write them.
+    void Pump();
+
+    //! Drains the buffer into the string that's being built, then traces the string when it hits a newline.
+    void ParseDataBuffer(AZ::u32 readSize, bool isFromStdErr);
+
+    //! Prints the current buffer to AZ_Error or AZ_TracePrintf so that it can be picked up by AZ::Debug::Trace
+    void WriteCurrentString(bool isFromStdError);
+
+private:
+    AZStd::string m_window;
+    AzFramework::ProcessCommunicator* m_communicator;
+    char m_streamBuffer[128];
+    AZStd::string m_stringBeingConcatenated;
+    AZStd::string m_errorStringBeingConcatenated;
+};

Code/Framework/AzFramework/AzFramework/Terrain/TerrainDataRequestBus.cpp

@@ -71,10 +71,11 @@ namespace AzFramework::Terrain
                 ->Event("GetSurfaceWeights", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetSurfaceWeights)
                 ->Event("GetSurfaceWeightsFromVector2",
                     &AzFramework::Terrain::TerrainDataRequestBus::Events::GetSurfaceWeightsFromVector2)
+                ->Event("GetIsHole", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetIsHole)
                 ->Event("GetIsHoleFromFloats", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetIsHoleFromFloats)
-                ->Event("GetSurfacePoint", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetSurfacePoint)
+                ->Event("GetSurfacePoint", &AzFramework::Terrain::TerrainDataRequestBus::Events::BehaviorContextGetSurfacePoint)
                 ->Event("GetSurfacePointFromVector2",
-                    &AzFramework::Terrain::TerrainDataRequestBus::Events::GetSurfacePointFromVector2)
+                    &AzFramework::Terrain::TerrainDataRequestBus::Events::BehaviorContextGetSurfacePointFromVector2)
                 ->Event("GetTerrainAabb", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetTerrainAabb)
                 ->Event("GetTerrainHeightQueryResolution",
                     &AzFramework::Terrain::TerrainDataRequestBus::Events::GetTerrainHeightQueryResolution)

Code/Framework/AzFramework/AzFramework/Terrain/TerrainDataRequestBus.h

@@ -52,8 +52,8 @@ namespace AzFramework
             virtual void SetTerrainAabb(const AZ::Aabb& worldBounds) = 0;
 
             //! Returns terrains height in meters at location x,y.
-            //! @terrainExistsPtr: Can be nullptr. If != nullptr then, if there's no terrain at location x,y or location x,y is inside a terrain HOLE then *terrainExistsPtr will become false,
-            //!                  otherwise *terrainExistsPtr will become true.
+            //! @terrainExistsPtr: Can be nullptr. If != nullptr then, if there's no terrain at location x,y or location x,y is inside
+            //!  a terrain HOLE then *terrainExistsPtr will become false, otherwise *terrainExistsPtr will become true.
             virtual float GetHeight(const AZ::Vector3& position, Sampler sampler = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
             virtual float GetHeightFromVector2(
                 const AZ::Vector2& position, Sampler sampler = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
@@ -68,8 +68,7 @@ namespace AzFramework
 
             // Given an XY coordinate, return the surface normal.
             //! @terrainExists: Can be nullptr. If != nullptr then, if there's no terrain at location x,y or location x,y is inside a
-            //! terrain HOLE then *terrainExistsPtr will be set to false,
-            //!                  otherwise *terrainExistsPtr will be set to true.
+            //! terrain HOLE then *terrainExistsPtr will be set to false, otherwise *terrainExistsPtr will be set to true.
             virtual AZ::Vector3 GetNormal(
                 const AZ::Vector3& position, Sampler sampleFilter = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
             virtual AZ::Vector3 GetNormalFromVector2(
@@ -78,8 +77,8 @@ namespace AzFramework
                 float x, float y, Sampler sampleFilter = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
 
             //! Given an XY coordinate, return the max surface type and weight.
-            //! @terrainExists: Can be nullptr. If != nullptr then, if there's no terrain at location x,y or location x,y is inside a terrain HOLE then *terrainExistsPtr will be set to false,
-            //!                  otherwise *terrainExistsPtr will be set to true.
+            //! @terrainExists: Can be nullptr. If != nullptr then, if there's no terrain at location x,y or location x,y is inside
+            //! a terrain HOLE then *terrainExistsPtr will be set to false, otherwise *terrainExistsPtr will be set to true.
             virtual SurfaceData::SurfaceTagWeight GetMaxSurfaceWeight(
                 const AZ::Vector3& position, Sampler sampleFilter = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
             virtual SurfaceData::SurfaceTagWeight GetMaxSurfaceWeightFromVector2(
@@ -87,8 +86,8 @@ namespace AzFramework
             virtual SurfaceData::SurfaceTagWeight GetMaxSurfaceWeightFromFloats(
                 float x, float y, Sampler sampleFilter = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
 
-            //! Given an XY coordinate, return the set of surface types and weights.  The Vector3 input position version is defined to ignore
-            //! the input Z value.
+            //! Given an XY coordinate, return the set of surface types and weights. The Vector3 input position version is defined to
+            //! ignore the input Z value.
             virtual void GetSurfaceWeights(
                 const AZ::Vector3& inPosition,
                 SurfaceData::SurfaceTagWeightList& outSurfaceWeights,
@@ -106,13 +105,14 @@ namespace AzFramework
                 Sampler sampleFilter = Sampler::DEFAULT,
                 bool* terrainExistsPtr = nullptr) const = 0;
 
-            //! Convenience function for  low level systems that can't do a reverse lookup from Crc to string. Everyone else should use GetMaxSurfaceWeight or GetMaxSurfaceWeightFromFloats.
+            //! Convenience function for  low level systems that can't do a reverse lookup from Crc to string. Everyone else should use
+            //! GetMaxSurfaceWeight or GetMaxSurfaceWeightFromFloats.
             //! Not available in the behavior context.
             //! Returns nullptr if the position is inside a hole or outside of the terrain boundaries.
             virtual const char* GetMaxSurfaceName(
                 const AZ::Vector3& position, Sampler sampleFilter = Sampler::BILINEAR, bool* terrainExistsPtr = nullptr) const = 0;
 
-            //! Given an XY coordinate, return all terrain information at that location.  The Vector3 input position version is defined
+            //! Given an XY coordinate, return all terrain information at that location. The Vector3 input position version is defined
             //! to ignore the input Z value.
             virtual void GetSurfacePoint(
                 const AZ::Vector3& inPosition,
@@ -132,6 +132,25 @@ namespace AzFramework
                 bool* terrainExistsPtr = nullptr) const = 0;
 
         private:
+            // Private variations of the GetSurfacePoint API exposed to BehaviorContext that returns a value instead of
+            // using an "out" parameter. The "out" parameter is useful for reusing memory allocated in SurfacePoint when
+            // using the public API, but can't easily be used from Script Canvas.
+            SurfaceData::SurfacePoint BehaviorContextGetSurfacePoint(
+                const AZ::Vector3& inPosition,
+                Sampler sampleFilter = Sampler::DEFAULT) const
+            {
+                SurfaceData::SurfacePoint result;
+                    GetSurfacePoint(inPosition, result, sampleFilter);
+                return result;
+            }
+            SurfaceData::SurfacePoint BehaviorContextGetSurfacePointFromVector2(
+                const AZ::Vector2& inPosition,
+                Sampler sampleFilter = Sampler::DEFAULT) const
+            {
+                SurfaceData::SurfacePoint result;
+                GetSurfacePointFromVector2(inPosition, result, sampleFilter);
+                return result;
+                
             // Functions without the optional bool* parameter that can be used from Python tests.
             float GetHeightVal(AZ::Vector3 position, Sampler sampler = Sampler::BILINEAR) const
             {

Code/Framework/AzFramework/AzFramework/Windowing/NativeWindow.cpp

@@ -143,6 +143,13 @@ namespace AzFramework
         return vsync_interval;
     }
 
+    bool NativeWindow::SetSyncInterval(uint32_t newSyncInterval)
+    {
+        vsync_interval = newSyncInterval;
+        return true;
+    }
+
+
     /*static*/ bool NativeWindow::GetFullScreenStateOfDefaultWindow()
     {
         NativeWindowHandle defaultWindowHandle = nullptr;

Code/Framework/AzFramework/AzFramework/Windowing/NativeWindow.h

@@ -132,6 +132,7 @@ namespace AzFramework
         void ToggleFullScreenState() override;
         float GetDpiScaleFactor() const override;
         uint32_t GetSyncInterval() const override;
+        bool SetSyncInterval(uint32_t newSyncInterval) override;
         uint32_t GetDisplayRefreshRate() const override;
 
         //! Get the full screen state of the default window.

Code/Framework/AzFramework/AzFramework/Windowing/WindowBus.h

@@ -78,6 +78,10 @@ namespace AzFramework
         //! Returns the sync interval which tells the drivers the number of v-blanks to synchronize with
         virtual uint32_t GetSyncInterval() const = 0;
 
+        //! Sets the sync interval which tells the drivers the number of v-blanks to synchronize with
+        //! Returns if the sync interval was succesfully set
+        virtual bool SetSyncInterval(uint32_t newSyncInterval) = 0;
+
         //! Returns the refresh rate of the main display
         virtual uint32_t GetDisplayRefreshRate() const = 0;
     };

Code/Framework/AzFramework/AzFramework/azframework_files.cmake

@@ -277,6 +277,8 @@ set(FILES
     Process/ProcessWatcher.cpp
     Process/ProcessWatcher.h
     Process/ProcessCommon_fwd.h
+    Process/ProcessCommunicatorTracePrinter.cpp
+    Process/ProcessCommunicatorTracePrinter.h
     ProjectManager/ProjectManager.h
     ProjectManager/ProjectManager.cpp
     Render/GameIntersectorComponent.h