Initial outdated master branch commit

OptiX.uplugin

@@ -20,6 +20,17 @@
       "Name": "OptiX",
       "Type": "Runtime",
       "LoadingPhase": "Default"
+    },
+    {
+      "Name": "OptiXEditor",
+      "Type": "Editor",
+      "LoadingPhase": "PostEngineInit"
     }
+  ],
+  "PostBuildSteps": 
+  {
+    "Win64": [
+      "FOR %%I in ($(PluginDir)\\Source\\OptiX\\Private\\cuda\\*.cu) DO nvcc -odir $(ProjectDir)\\Content\\ptx\\generated -ccbin \"C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Professional\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x64\" -ptx %%I -I$(PluginDir)\\Source\\ThirdParty\\OptiXLibrary\\include -use_fast_math"
     ]
   }
+}
\ No newline at end of file

Source/OptiX/OptiX.Build.cs

@@ -14,7 +14,7 @@ public class OptiX : ModuleRules
         string EnginePath = Path.GetFullPath(Target.RelativeEnginePath);
         string ModulePath = ModuleDirectory;
 
-        PublicDefinitions.Add("MALLOC_LEAKDETECTION=0");
+        Definitions.Add("MALLOC_LEAKDETECTION=0");
 
 
         PublicIncludePaths.AddRange(
@@ -47,11 +47,6 @@ public class OptiX : ModuleRules
                 "UMG",
                 "Slate",
                 "SlateCore",
-                "D3D11RHI",
-                "UtilityShaders",
-                "Analytics",
-                "EngineSettings"
-
             }
             );
         PrivateDependencyModuleNames.AddRange(
@@ -67,11 +62,7 @@ public class OptiX : ModuleRules
                 "Json",
                 "JsonUtilities",
                 "RenderCore",
-                "RHI",
-                "D3D11RHI",
-                "UtilityShaders",
-                "Analytics",
-                "EngineSettings"
+                "RHI"
             }
             );
 

Source/OptiX/Private/LineInstancedStaticMeshComponent.cpp

 // Fill out your copyright notice in the Description page of Project Settings.
 
+
 #include "LineInstancedStaticMeshComponent.h"
 
 #include "Components/InstancedStaticMeshComponent.h"
@@ -13,9 +14,6 @@
 #include "OptiXModule.h"
 #include "OptiXContextManager.h"
 
-#include "StatsDefines.h"
-
-
 
 ULineInstancedStaticMeshComponent::ULineInstancedStaticMeshComponent(const FObjectInitializer& ObjectInitializer)
 	: Super(ObjectInitializer)
@@ -47,7 +45,6 @@ void ULineInstancedStaticMeshComponent::BeginPlay()
 
 FPrimitiveSceneProxy* ULineInstancedStaticMeshComponent::CreateSceneProxy()
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("ULineInstancedStaticMeshComponent::CreateSceneProxy"))
 
 
 	FPrimitiveSceneProxy* Proxy = Super::CreateSceneProxy();
@@ -85,7 +82,6 @@ FPrimitiveSceneProxy* ULineInstancedStaticMeshComponent::CreateSceneProxy()
 // todo currently copies the array, save a reference/ptr instead
 void ULineInstancedStaticMeshComponent::InitLineSegments(TArray<int32> Indices, int32 NumberOfSegmentsPerLine, float LineW)
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("ULineInstancedStaticMeshComponent::InitLineSegments"))
 
 	ClearInstances();
 	
@@ -142,7 +138,7 @@ void ULineInstancedStaticMeshComponent::InitLineSegments(TArray<int32> Indices,
 
 		IndexMap = UTexture2D::CreateTransient(1, LineNumber, EPixelFormat::PF_R32_FLOAT);
 		IndexMap->UpdateResource();
-		UE_LOG(LogTemp, Display, TEXT("IndexMap | LineNumber (%i | %i )"), IndexMap->GetSizeX(), LineNumber);
+		UE_LOG(LogTemp, Display, TEXT("IndexMap | LineNumber (%i | %i "), IndexMap->GetSizeX(), LineNumber);
 		IndexMap->UpdateTextureRegions(0, 1, TextureRegion.Get(), sizeof(float), sizeof(float), (uint8*)LaserIndicesFloat.GetData());
 		DynamicLaserMaterial->SetTextureParameterValue("IndexMap", IndexMap);
 
@@ -153,8 +149,6 @@ void ULineInstancedStaticMeshComponent::InitLineSegments(TArray<int32> Indices,
 
 void ULineInstancedStaticMeshComponent::UpdateLines()
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("ULineInstancedStaticMeshComponent::UpdateLines"))
-
 	LineNumber = LaserIndices.Num();
 
 	for (int32 Line = 0; Line < LineNumber; Line++)
@@ -181,8 +175,6 @@ void ULineInstancedStaticMeshComponent::UpdateLines()
 
 void  ULineInstancedStaticMeshComponent::UpdateLUT(TArray<FColor> ColorMap)
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("ULineInstancedStaticMeshComponent::UpdateLUT"))
-
 	if (DynamicLaserMaterial != NULL)
 	{
 
@@ -205,8 +197,6 @@ void  ULineInstancedStaticMeshComponent::UpdateLUT(TArray<FColor> ColorMap)
 
 void ULineInstancedStaticMeshComponent::SetLaserMaterial(UMaterialInstanceDynamic * Mat)
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("ULineInstancedStaticMeshComponent::SetLaserMaterial"))
-
 	// 1 for now, could be #Lines if we want multicolored lines
 	ColorLUT = UTexture2D::CreateTransient(1, LineNumber, EPixelFormat::PF_R32_FLOAT);
 	ColorLUT->UpdateResource();

Source/OptiX/Private/OptiXAcceleration.cpp

+#include "OptiXAcceleration.h"
+
+#include "CoreMinimal.h"
+#include "UObject/ObjectMacros.h"
+#include "Engine/EngineTypes.h"
+
+// Needed for debugging
+#include <EngineGlobals.h>
+#include <Runtime/Engine/Classes/Engine/Engine.h>
+
+#include "OptiXModule.h"
+
+DEFINE_LOG_CATEGORY(OptiXPluginAcceleration);
+
+void UOptiXAcceleration::BeginDestroy()
+{
+	Super::BeginDestroy();
+	DestroyOptiXObject();
+}
+
+void UOptiXAcceleration::DestroyOptiXObject()
+{
+	if (NativeAcceleration != NULL)
+	{
+		//NativeAcceleration->destroy();
+		FOptiXModule::Get().GetOptiXContextManager()->AccelerationsToDeleteQueue.Enqueue(NativeAcceleration);
+	}
+	NativeAcceleration = NULL;
+}
+
+void UOptiXAcceleration::Validate()
+{
+	try
+	{
+		NativeAcceleration->validate();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXAcceleration::MarkDirty()
+{
+	try
+	{
+		NativeAcceleration->markDirty();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+bool UOptiXAcceleration::IsDirty()
+{
+	bool B = false;
+	try
+	{
+		B = NativeAcceleration->isDirty();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return B;
+}
+
+void UOptiXAcceleration::SetProperty(FString Name, FString Value)
+{
+	try
+	{
+		std::string N = std::string(TCHAR_TO_ANSI(*Name));
+		std::string V = std::string(TCHAR_TO_ANSI(*Value));
+
+		NativeAcceleration->setProperty(N, V);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+FString UOptiXAcceleration::GetProperty(FString Name)
+{
+	FString Property;
+	try
+	{
+		std::string N = std::string(TCHAR_TO_ANSI(*Name));
+		std::string V = NativeAcceleration->getProperty(N);
+		Property = FString(V.c_str());
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Property;
+}
+
+void UOptiXAcceleration::SetBuilder(FString Builder)
+{
+	try
+	{
+		std::string N = std::string(TCHAR_TO_ANSI(*Builder));
+
+		NativeAcceleration->setBuilder(N);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+FString UOptiXAcceleration::GetBuilder()
+{
+	FString Property;
+	try
+	{
+		std::string V = NativeAcceleration->getBuilder();
+		Property = FString(V.c_str());
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Property;
+}
+
+void UOptiXAcceleration::SetTraverser(FString Traverser)
+{
+	try
+	{
+		std::string N = std::string(TCHAR_TO_ANSI(*Traverser));
+
+		NativeAcceleration->setTraverser(N);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+FString UOptiXAcceleration::GetTraverser()
+{
+	FString Property;
+	try
+	{
+		std::string V = NativeAcceleration->getTraverser();
+		Property = FString(V.c_str());
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Property;
+}
+
+RTsize UOptiXAcceleration::GetDataSize()
+{
+	RTsize Size = 0;
+	try
+	{
+		Size = NativeAcceleration->getDataSize();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Size;
+}
+
+void UOptiXAcceleration::GetData(void * Data)
+{
+	try
+	{
+		NativeAcceleration->getData(Data);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXAcceleration::SetData(void * Data, RTsize Size)
+{
+	try
+	{
+		NativeAcceleration->setData(Data, Size);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginAcceleration, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}

Source/OptiX/Private/OptiXBuffer.cpp

+#include "OptiXBuffer.h"
+
+#include "CoreMinimal.h"
+#include "UObject/ObjectMacros.h"
+#include "Engine/EngineTypes.h"
+
+//#include "OptiXModule.h"
+
+// Needed for debugging
+#include <EngineGlobals.h>
+#include <Runtime/Engine/Classes/Engine/Engine.h>
+
+#include "OptiXModule.h"
+
+DEFINE_LOG_CATEGORY(OptiXPluginBuffer);
+
+void UOptiXBuffer::BeginDestroy()
+{
+	UE_LOG(LogTemp, Warning, TEXT("OptiX Buffer BeginDestroy"));
+	DestroyOptiXObject();
+	Super::BeginDestroy();
+}
+
+void UOptiXBuffer::DestroyOptiXObject()
+{
+	if (NativeBuffer != NULL)
+	{
+		UE_LOG(LogTemp, Display, TEXT("Buffer Name: %s!"), *Name);
+		try
+		{
+			//NativeBuffer->destroy();
+			FOptiXModule::Get().GetOptiXContextManager()->BuffersToDeleteQueue.Enqueue(NativeBuffer);
+		}
+		catch (optix::Exception& E)
+		{
+			FString Message = FString(E.getErrorString().c_str());
+			UE_LOG(OptiXPluginBuffer, Fatal, TEXT("OptiX Error: %s"), *Message);
+			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+		}
+	}
+
+	NativeBuffer = NULL;
+}
+
+void UOptiXBuffer::Validate()
+{
+	try
+	{
+		NativeBuffer->validate();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetFormat(RTformat Format)
+{
+	try
+	{
+		NativeBuffer->setFormat(Format);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+RTformat UOptiXBuffer::GetFormat()
+{
+	return NativeBuffer->getFormat();
+}
+
+void UOptiXBuffer::SetElementSize(int32 Size)
+{
+	try
+	{
+		NativeBuffer->setElementSize(Size);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetElementSizeNative(RTsize Size)
+{
+	try
+	{
+		NativeBuffer->setElementSize(Size);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+
+RTsize UOptiXBuffer::GetElementSizeNative()
+{
+	RTsize S = 0;
+	try
+	{
+		S = NativeBuffer->getElementSize();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return S;
+}
+
+int32 UOptiXBuffer::GetElementSize()
+{
+	int32 S = 0;
+	try
+	{
+		S = NativeBuffer->getElementSize();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return S;
+}
+
+void UOptiXBuffer::MarkDirty()
+{
+	try
+	{
+		NativeBuffer->markDirty();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetSize1D(int32 Width)
+{
+	try
+	{
+		NativeBuffer->setSize(Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetSize1DNative(RTsize Width)
+{
+	try
+	{
+		NativeBuffer->setSize(Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+RTsize UOptiXBuffer::GetSize1DNative()
+{
+	RTsize Width;
+	try
+	{
+		NativeBuffer->getSize(Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Width;
+}
+
+int32 UOptiXBuffer::GetSize1D()
+{
+	RTsize Width;
+	try
+	{
+		NativeBuffer->getSize(Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return static_cast<int32>(Width);
+}
+
+RTsize UOptiXBuffer::GetMipLevelSize1DNative(uint8 Level)
+{
+	RTsize Width;
+	try
+	{
+		NativeBuffer->getMipLevelSize(Level, Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Width;
+}
+
+int32 UOptiXBuffer::GetMipLevelSize1D(uint8 Level)
+{
+	RTsize Width;
+	try
+	{
+		NativeBuffer->getMipLevelSize(Level, Width);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return static_cast<int32>(Width);
+}
+
+void UOptiXBuffer::SetSize2D(int32 Width, int32 Height)
+{
+	try
+	{
+		NativeBuffer->setSize(Width, Height);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetSize2DNative(RTsize Width, RTsize Height)
+{
+	try
+	{
+		NativeBuffer->setSize(Width, Height);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+RTsize2 UOptiXBuffer::GetSize2DNative()
+{
+	RTsize2 S;
+	RTsize A;
+	RTsize B;
+	NativeBuffer->getSize(A, B);
+	S.X = A;
+	S.Y = B;
+	return S;
+}
+
+FIntPoint UOptiXBuffer::GetSize2D()
+{
+	FIntPoint S;
+	RTsize A;
+	RTsize B;
+	try
+	{
+		NativeBuffer->getSize(A, B);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	S.X = A;
+	S.Y = B;
+	return S;
+}
+
+FIntPoint UOptiXBuffer::GetMipLevelSize2D(uint8 Level)
+{
+	FIntPoint S;
+	RTsize A = 0;
+	RTsize B = 0;
+	try
+	{
+		NativeBuffer->getMipLevelSize(A, B);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}	
+	S.X = A;
+	S.Y = B;
+	return S;
+}
+
+RTsize2 UOptiXBuffer::GetMipLevelSize2DNative(uint8 Level)
+{
+	RTsize2 S;
+	RTsize A = 0;
+	RTsize B = 0;
+	try
+	{
+		NativeBuffer->getMipLevelSize(A, B);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}	
+	S.X = A;
+	S.Y = B;
+	return S;
+}
+
+void UOptiXBuffer::SetSize3DNative(RTsize Width, RTsize Height, RTsize Depth)
+{
+	try
+	{
+		NativeBuffer->setSize(Width, Height, Depth);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::SetSize3D(int32 Width, int32 Height, int32 Depth)
+{
+	try
+	{
+		NativeBuffer->setSize(Width, Height, Depth);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+FIntVector UOptiXBuffer::GetSize3D()
+{
+	FIntVector S;
+	RTsize A;
+	RTsize B;
+	RTsize C;
+	try
+	{
+		NativeBuffer->getSize(A, B, C);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	S.X = A;
+	S.Y = B;	
+	S.Z = C;
+	return S;
+}
+
+
+RTsize3 UOptiXBuffer::GetSize3DNative()
+{
+	RTsize3 S;
+	RTsize A;
+	RTsize B;
+	RTsize C;
+	try
+	{
+		NativeBuffer->getSize(A, B, C);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	S.X = A;
+	S.Y = B;
+	S.Z = C;
+	return S;
+}
+
+FIntVector UOptiXBuffer::GetMipLevelSize3D(uint8 Level)
+{
+	FIntVector S;
+	RTsize A = 0;
+	RTsize B = 0;
+	RTsize C = 0;
+	try
+	{
+		NativeBuffer->getMipLevelSize(A, B, C);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	S.X = A;
+	S.Y = B;
+	S.Z = C;
+	return S;
+}
+
+RTsize3 UOptiXBuffer::GetMipLevelSize3DNative(uint8 Level)
+{
+	RTsize3 S;
+	RTsize A = 0;
+	RTsize B = 0;
+	RTsize C = 0;
+	try
+	{
+		NativeBuffer->getMipLevelSize(A, B, C);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	S.X = A;
+	S.Y = B;
+	S.Z = C;
+	return S;
+}
+
+void UOptiXBuffer::SetMipLevelCount(uint8 Count)
+{
+	try
+	{
+		NativeBuffer->setMipLevelCount(Count);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+uint8 UOptiXBuffer::GetMipLevelCount()
+{
+	uint8 Count = 0;
+	try
+	{
+		Count = NativeBuffer->getMipLevelCount();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Count;
+}
+
+int UOptiXBuffer::GetId()
+{
+	int Id = 0;
+	try
+	{
+		Id = NativeBuffer->getId();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Id;
+}
+
+void UOptiXBuffer::Map(uint8 Level, uint8 MapFlags)
+{
+	try
+	{
+		NativeBuffer->map(Level, MapFlags);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+
+void * UOptiXBuffer::MapNative(uint8 Level, uint8 MapFlags, void * UserOwned)
+{
+	void * Ptr = nullptr;
+	try
+	{
+		Ptr = NativeBuffer->map(Level, MapFlags, UserOwned);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Ptr;
+}
+
+void UOptiXBuffer::Unmap(uint8 Level)
+{
+	try
+	{
+		NativeBuffer->unmap(Level);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+// TODO: Wrap those a bit better
+
+void UOptiXBuffer::BindProgressiveStream(UOptiXBuffer * Source)
+{
+	try
+	{
+		NativeBuffer->bindProgressiveStream(Source->GetNativeBuffer());
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::GetProgressiveUpdateReady(int * Ready, unsigned int * SubframeCount, unsigned int * MaxSubframes)
+{
+	try
+	{
+		NativeBuffer->getProgressiveUpdateReady(Ready, SubframeCount, MaxSubframes);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+bool UOptiXBuffer::GetProgressiveUpdateReady()
+{
+	bool Ready = false;
+	try
+	{
+		Ready = NativeBuffer->getProgressiveUpdateReady();
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Ready;
+}
+
+void UOptiXBuffer::GetDevicePointer(int32 OptiXDeviceOrdinal, void ** DevicePointer)
+{
+	try
+	{
+		NativeBuffer->getDevicePointer(OptiXDeviceOrdinal, DevicePointer);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void * UOptiXBuffer::GetDevicePointer(int32 OptiXDeviceOrdinal)
+{
+	void* Ptr = nullptr;
+	try
+	{
+		Ptr = NativeBuffer->getDevicePointer(OptiXDeviceOrdinal);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Ptr;
+}
+
+void UOptiXBuffer::SetDevicePointer(int32 OptiXDeviceOrdinal, void * DevicePointer)
+{
+	try
+	{
+		NativeBuffer->setDevicePointer(OptiXDeviceOrdinal, DevicePointer);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+bool UOptiXBuffer::GetProgressiveUpdateReady(unsigned int & SubframeCount)
+{
+	bool Ready = false;
+	try
+	{
+		Ready = NativeBuffer->getProgressiveUpdateReady(SubframeCount);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Ready;
+}
+
+bool UOptiXBuffer::GetProgressiveUpdateReady(unsigned int & SubframeCount, unsigned int & MaxSubframes)
+{
+	bool Ready = false;
+	try
+	{
+		Ready = NativeBuffer->getProgressiveUpdateReady(SubframeCount, MaxSubframes);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+	return Ready;
+}
+
+void UOptiXBuffer::SetAttribute(RTbufferattribute Attrib, RTsize Size, void * P)
+{
+	try
+	{
+		NativeBuffer->setAttribute(Attrib, Size, P);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
+
+void UOptiXBuffer::GetAttribute(RTbufferattribute Attrib, RTsize Size, void * P)
+{
+	try
+	{
+		NativeBuffer->getAttribute(Attrib, Size, P);
+	}
+	catch (optix::Exception& E)
+	{
+		FString Message = FString(E.getErrorString().c_str());
+		UE_LOG(OptiXPluginBuffer, Error, TEXT("OptiX Error: %s"), *Message);
+		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("OptiX Error %s"), *Message));
+	}
+}
\ No newline at end of file

Source/OptiX/Private/OptiXCameraActor.cpp

@@ -3,6 +3,7 @@
 #include "OptiXCameraActor.h"
 
 #include "OptiXModule.h"
+#include "OptiXTextureSampler.h"
 #include "OptiXLaserActor.h"
 
 #include "Engine/EngineTypes.h"
@@ -27,8 +28,6 @@
 
 #include "Runtime/Engine/Classes/Camera/CameraActor.h"
 
-#include "StatsDefines.h"
-
 
 DEFINE_LOG_CATEGORY(OptiXPluginCameraActor);
 
@@ -130,8 +129,6 @@ void AOptiXPlayerCameraManager::EndPlay(const EEndPlayReason::Type EndPlayReason
 
 void AOptiXPlayerCameraManager::Tick(float DeltaSeconds)
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("AOptiXPlayerCameraManager::Tick"))
-
 	Super::Tick(DeltaSeconds);
 	if (C == 2)
 	{
@@ -158,7 +155,6 @@ void AOptiXPlayerCameraManager::Init()
 
 void AOptiXPlayerCameraManager::CaptureCubemap()
 {
-	TRACE_CPUPROFILER_EVENT_SCOPE(TEXT("AOptiXPlayerCameraManager::CaptureCubemap"))
 
 	// 2D
 	TArray<FVector> Directions =

Source/OptiX/Private/OptiXCubemapLateUpdateComponent.cpp

-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "OptiXCubemapLateUpdateComponent.h"
-
-#include "PrimitiveSceneProxy.h"
-#include "OptiXModule.h"
-
-FPrimitiveSceneProxy* UOptiXCubemapLateUpdateComponent::CreateSceneProxy()
-{
-	class FOptiXCubemapComponentSceneProxy final : public FPrimitiveSceneProxy
-	{
-	public:
-		SIZE_T GetTypeHash() const override
-		{
-			static size_t UniquePointer;
-			return reinterpret_cast<size_t>(&UniquePointer);
-		}
-
-		/** Initialization constructor. */
-		FOptiXCubemapComponentSceneProxy(const UOptiXCubemapLateUpdateComponent* InComponent)
-			: FPrimitiveSceneProxy(InComponent), UniqueId(InComponent->GetOptiXComponentId())
-		{
-		}
-
-		// FPrimitiveSceneProxy interface.
-
-		virtual void ApplyLateUpdateTransform(const FMatrix& LateUpdateTransform) override
-		{
-
-			FMatrix NewTransform = GetLocalToWorld() * LateUpdateTransform;
-			FVector OriginChange = NewTransform.GetOrigin() - GetLocalToWorld().GetOrigin();
-			FMatrix ReducedLateUpdate = FMatrix::Identity;
-			ReducedLateUpdate.SetOrigin(OriginChange);
-
-			FPrimitiveSceneProxy::ApplyLateUpdateTransform(ReducedLateUpdate);
-
-
-			//FMatrix CachedTransform = GetLocalToWorld();
-			//FPrimitiveSceneProxy::ApplyLateUpdateTransform(LateUpdateTransform);
-			//CachedTransform.SetOrigin(GetLocalToWorld().GetOrigin());
-			////UE_LOG(LogTemp, Display, TEXT("Transform on late update: %s"), *UpdatedTransform.ToString());
-			FOptiXModule::Get().GetOptiXContextManager()->ObjectPositionLateUpdate_RenderThread(*UniqueId, GetLocalToWorld().GetMatrixWithoutScale());
-		}
-
-		virtual uint32 GetMemoryFootprint(void) const override { return(sizeof(*this) + GetAllocatedSize()); }
-		uint32 GetAllocatedSize(void) const { return(FPrimitiveSceneProxy::GetAllocatedSize()); }
-	private:
-		const uint32* UniqueId;
-	};
-
-	return new FOptiXCubemapComponentSceneProxy(this);
-}
-
-void UOptiXCubemapLateUpdateComponent::LinkOptiXComponent(UOptiXCubemapComponent* OptiXComponent)
-{
-	OptiXComponentId = OptiXComponent->GetUniqueID();
-	UE_LOG(LogTemp, Display, TEXT("Setting Unique id on UOptiXCubemapComponent: %i"), OptiXComponentId);
-}