Bump OculusVR RIFT SDK to 0.5.0.1vanilla_0.5.0.1

1 files changed, 591 insertions, 0 deletions

diff --git a/LibOVRKernel/Src/Util/Util_ImageWindow.cpp b/LibOVRKernel/Src/Util/Util_ImageWindow.cpp
new file mode 100644
index 0000000..93a1aa4
--- /dev/null
+++ b/LibOVRKernel/Src/Util/Util_ImageWindow.cpp
@@ -0,0 +1,591 @@
+/************************************************************************************
+
+Filename    :   Util_ImageWindow.cpp
+Content     :   An output object for windows that can display raw images for testing
+Created     :   March 13, 2014
+Authors     :   Dean Beeler
+
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.2 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*************************************************************************************/
+
+
+#include "Kernel/OVR_Types.h"
+
+OVR_DISABLE_ALL_MSVC_WARNINGS()
+
+#include "Kernel/OVR_Allocator.h"
+#include "Kernel/OVR_RefCount.h"
+#include "Kernel/OVR_Log.h"
+#include "Kernel/OVR_System.h"
+#include "Kernel/OVR_Nullptr.h"
+#include "Kernel/OVR_String.h"
+#include "Kernel/OVR_Array.h"
+#include "Kernel/OVR_Timer.h"
+#include "Kernel/OVR_SysFile.h"
+
+#include "Util_ImageWindow.h"
+
+#if defined(OVR_OS_WIN32)
+    #include "Kernel/OVR_Win32_IncludeWindows.h"
+    #include "DWrite.h"
+#endif
+
+OVR_RESTORE_ALL_MSVC_WARNINGS()
+
+
+#if defined(OVR_OS_WIN32)
+
+typedef HRESULT (WINAPI *D2D1CreateFactoryFn)(
+	_In_      D2D1_FACTORY_TYPE,
+	_In_      REFIID,
+	_In_opt_  const D2D1_FACTORY_OPTIONS*,
+	_Out_     ID2D1Factory **
+	);
+
+typedef HRESULT (WINAPI *DWriteCreateFactoryFn)(
+	_In_   DWRITE_FACTORY_TYPE factoryType,
+	_In_   REFIID iid,
+	_Out_  IUnknown **factory
+	);
+
+
+namespace OVR { namespace Util {
+	
+ID2D1Factory* ImageWindow::pD2DFactory = NULL;
+IDWriteFactory* ImageWindow::pDWriteFactory = NULL;
+HINSTANCE ImageWindow::hInstD2d1 = NULL;
+HINSTANCE ImageWindow::hInstDwrite = NULL;
+
+
+// TODO(review): This appears to be (at present) necessary, the global list is accessed by the
+// render loop in Samples.  In the current version, windows will just be lost when windowCount
+// exceeds MaxWindows; I've left that in place, since this is unfamiliar code. I'm not sure what
+// thread-safety guarantees this portion of the code needs to satisfy, so I don't want to
+// change it to a list or whatever.  Asserts added to catch the error.
+ImageWindow* ImageWindow::globalWindow[ImageWindow::MaxWindows];
+int ImageWindow::windowCount = 0;
+
+LRESULT CALLBACK MainWndProc(
+	HWND hwnd,
+	UINT uMsg,
+	WPARAM wParam,
+	LPARAM lParam)
+{
+	switch (uMsg) 
+	{ 
+	case WM_CREATE: 
+		return 0; 
+
+	case WM_PAINT: 
+		{
+			LONG_PTR ptr = GetWindowLongPtr( hwnd, GWLP_USERDATA );
+			if( ptr )
+			{
+				ImageWindow* iw = (ImageWindow*)ptr;
+				iw->OnPaint();
+			}
+		}
+		
+		return 0; 
+
+	case WM_SIZE: 
+		// Set the size and position of the window. 
+		return 0; 
+
+	case WM_DESTROY: 
+		// Clean up window-specific data objects. 
+		return 0; 
+
+		// 
+		// Process other messages. 
+		// 
+
+	default: 
+		return DefWindowProc(hwnd, uMsg, wParam, lParam); 
+	} 
+	//return 0; 
+}
+
+
+ImageWindow::ImageWindow( uint32_t width, uint32_t height ) :
+	hWindow(NULL), 
+    pRT(NULL), 
+  //resolution(),
+    frontBufferMutex( new Mutex() ),
+    frames(),
+    greyBitmap(NULL),
+    colorBitmap(NULL)
+{
+	D2D1CreateFactoryFn createFactory = NULL;
+	DWriteCreateFactoryFn writeFactory = NULL;
+
+	if (!hInstD2d1)
+    {
+        hInstD2d1 = LoadLibraryW( L"d2d1.dll" );
+    }
+
+	if (!hInstD2d1)
+    {
+	    hInstD2d1 = LoadLibraryW( L"Dwrite.dll" );
+    }
+
+	if( hInstD2d1 )
+	{
+		createFactory = (D2D1CreateFactoryFn)GetProcAddress( hInstD2d1, "D2D1CreateFactory" );
+	}
+
+	if( hInstDwrite )
+	{
+		writeFactory = (DWriteCreateFactoryFn)GetProcAddress( hInstDwrite, "DWriteCreateFactory" );
+	}
+
+    // TODO: see note where globalWindow is declared.
+	globalWindow[windowCount++ % MaxWindows] = this;
+    OVR_ASSERT(windowCount < MaxWindows);
+
+	if( pD2DFactory == NULL && createFactory && writeFactory )
+	{
+        // Create a Direct2D factory.
+		HRESULT hResult = createFactory( 
+			D2D1_FACTORY_TYPE_MULTI_THREADED,
+			__uuidof(ID2D1Factory),
+			NULL,
+			&pD2DFactory // This will be AddRef'd for us.
+			);
+        OVR_ASSERT_AND_UNUSED(hResult == S_OK, hResult);
+
+		// Create a DirectWrite factory.
+		hResult = writeFactory(
+			DWRITE_FACTORY_TYPE_SHARED,
+			__uuidof(pDWriteFactory), // This probably should instead be __uuidof(IDWriteFactory)
+			reinterpret_cast<IUnknown **>(&pDWriteFactory)  // This will be AddRef'd for us.
+			);
+        OVR_ASSERT_AND_UNUSED(hResult == S_OK, hResult);
+	}
+
+	resolution = D2D1::SizeU( width, height );
+
+	if (hWindow)
+    {
+        SetWindowLongPtr( hWindow, GWLP_USERDATA, (LONG_PTR)this );
+    }
+}
+
+ImageWindow::~ImageWindow()
+{
+	for( int i = 0; i < MaxWindows; ++i )
+	{
+		if( globalWindow[i] == this )
+		{
+			globalWindow[i] = NULL;
+			break;
+		}
+    }
+
+	if( greyBitmap )
+		greyBitmap->Release();
+
+	if( colorBitmap )
+		colorBitmap->Release();
+
+	if( pRT )
+		pRT->Release();
+
+	{
+		Mutex::Locker locker( frontBufferMutex  );
+
+		while( frames.GetSize() )
+		{
+			Ptr<Frame> aFrame = frames.PopBack();
+		}
+	}
+
+	delete frontBufferMutex;
+
+	if (hWindow)
+    {
+	    ShowWindow( hWindow, SW_HIDE );
+	    DestroyWindow( hWindow );
+    }
+
+    if (pD2DFactory)
+    {
+        pD2DFactory->Release();
+        pD2DFactory = NULL;
+    }
+
+    if (pDWriteFactory)
+    {
+        pDWriteFactory->Release();
+        pDWriteFactory = NULL;
+    }
+
+	if( hInstD2d1 )
+	{
+		FreeLibrary(hInstD2d1);
+        hInstD2d1 = NULL;
+	}
+
+	if( hInstDwrite )
+	{
+		FreeLibrary(hInstDwrite);
+        hInstDwrite = NULL;
+	}
+}
+
+void ImageWindow::AssociateSurface( void* surface )
+{
+    if (pD2DFactory)
+    {
+	    // Assume an IUnknown
+	    IUnknown* unknown = (IUnknown*)surface;
+
+	    IDXGISurface *pDxgiSurface = NULL;
+	    HRESULT hr = unknown->QueryInterface(&pDxgiSurface);
+	    if( hr == S_OK )
+	    {
+		    D2D1_RENDER_TARGET_PROPERTIES props =
+			    D2D1::RenderTargetProperties(
+			    D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			    D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
+			    96,
+			    96
+			    );
+
+		    pRT = NULL;			
+		    ID2D1RenderTarget* tmpTarget;
+
+        	hr = pD2DFactory->CreateDxgiSurfaceRenderTarget( pDxgiSurface, &props, &tmpTarget );
+
+		    if( hr == S_OK )
+		    {
+			    DXGI_SURFACE_DESC desc = {0};
+			    pDxgiSurface->GetDesc( &desc );
+			    int width = desc.Width;
+			    int height = desc.Height;
+
+			    D2D1_SIZE_U size = D2D1::SizeU( width, height );
+
+			    D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat(
+				    DXGI_FORMAT_A8_UNORM,
+				    D2D1_ALPHA_MODE_PREMULTIPLIED
+				    );
+
+			    D2D1_PIXEL_FORMAT colorPixelFormat = D2D1::PixelFormat(
+				    DXGI_FORMAT_B8G8R8A8_UNORM,
+				    D2D1_ALPHA_MODE_PREMULTIPLIED
+				    );
+
+			    D2D1_BITMAP_PROPERTIES bitmapProps;
+			    bitmapProps.dpiX = 96;
+			    bitmapProps.dpiY = 96;
+			    bitmapProps.pixelFormat = pixelFormat;
+
+			    D2D1_BITMAP_PROPERTIES colorBitmapProps;
+			    colorBitmapProps.dpiX = 96;
+			    colorBitmapProps.dpiY = 96;
+			    colorBitmapProps.pixelFormat = colorPixelFormat;
+
+			    HRESULT result = tmpTarget->CreateBitmap( size, bitmapProps, &greyBitmap );
+			    if( result != S_OK )
+			    {
+				    tmpTarget->Release();
+				    tmpTarget = NULL;
+			    }
+
+			    if (tmpTarget)
+			    {
+				    result = tmpTarget->CreateBitmap(size, colorBitmapProps, &colorBitmap);
+				    if (result != S_OK)
+				    {
+					    tmpTarget->Release();
+					    tmpTarget = NULL;
+				    }
+			    }
+			    pRT = tmpTarget;
+		    }
+	    }
+    }
+}
+
+void ImageWindow::Process()
+{
+	if( pRT && greyBitmap )
+	{
+		OnPaint();
+
+		pRT->Flush();
+	}
+}
+
+void ImageWindow::Complete()
+{
+	Mutex::Locker locker( frontBufferMutex  );
+
+	if( frames.IsEmpty() )
+		return;
+
+	if( frames.PeekBack(0)->ready )
+		return;
+
+	Ptr<Frame> frame = frames.PeekBack(0);
+
+	frame->ready = true;
+}
+
+void ImageWindow::OnPaint()
+{
+	Mutex::Locker locker( frontBufferMutex  );
+
+	// Nothing to do
+	if( frames.IsEmpty() )
+		return;
+
+	if( !frames.PeekFront(0)->ready )
+		return;
+
+	Ptr<Frame> currentFrame = frames.PopFront();
+
+	Ptr<Frame> nextFrame = NULL;
+
+	if( !frames.IsEmpty() )
+		nextFrame = frames.PeekFront(0);
+	
+	while( nextFrame && nextFrame->ready )
+	{
+		// Free up the current frame since it's been removed from the deque
+		currentFrame = frames.PopFront();
+
+		if( frames.IsEmpty() )
+			break;
+
+		nextFrame = frames.PeekFront(0);
+	}
+
+	if( currentFrame->imageData )
+		greyBitmap->CopyFromMemory( NULL, currentFrame->imageData, currentFrame->width );
+
+	if( currentFrame->colorImageData )
+		colorBitmap->CopyFromMemory( NULL, currentFrame->colorImageData, currentFrame->colorPitch );
+
+	pRT->BeginDraw();
+
+	pRT->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED); 
+
+	pRT->Clear( D2D1::ColorF(D2D1::ColorF::Black) );
+
+	// This will mirror our image
+	D2D1_MATRIX_3X2_F m;
+	m._11 = -1; m._12 = 0;
+	m._21 = 0; m._22 = 1;
+	m._31 = 0; m._32 = 0;
+	pRT->SetTransform( m );
+
+	ID2D1SolidColorBrush* whiteBrush;
+
+	pRT->CreateSolidColorBrush( D2D1::ColorF(D2D1::ColorF::White, 1.0f), &whiteBrush );
+
+	if( currentFrame->imageData )
+	{
+		pRT->FillOpacityMask( greyBitmap, whiteBrush, 
+			D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL, 
+			D2D1::RectF( -(FLOAT)resolution.width, 0.0f, (FLOAT)0.0f, (FLOAT)resolution.height ), 
+			//D2D1::RectF( 0.0f, 0.0f, (FLOAT)0.0f, (FLOAT)resolution.height ), 
+			D2D1::RectF( 0.0f, 0.0f, (FLOAT)resolution.width, (FLOAT)resolution.height ) );
+	}
+	else if( currentFrame->colorImageData )
+	{
+		pRT->DrawBitmap( colorBitmap,
+			D2D1::RectF( -(FLOAT)resolution.width, 0.0f, (FLOAT)0.0f, (FLOAT)resolution.height ) );
+
+	}
+
+	pRT->SetTransform(D2D1::Matrix3x2F::Identity());
+
+	whiteBrush->Release();
+
+	Array<CirclePlot>::Iterator it;
+
+	for( it = currentFrame->plots.Begin(); it != currentFrame->plots.End(); ++it )
+	{
+		ID2D1SolidColorBrush* aBrush;
+
+		pRT->CreateSolidColorBrush( D2D1::ColorF( it->r, it->g, it->b), &aBrush );
+
+		D2D1_ELLIPSE ellipse;
+		ellipse.point.x = it->x;
+		ellipse.point.y = it->y;
+		ellipse.radiusX = it->radius;
+		ellipse.radiusY = it->radius;
+
+		if( it->fill )
+			pRT->FillEllipse( &ellipse, aBrush );
+		else
+			pRT->DrawEllipse( &ellipse, aBrush );
+
+		aBrush->Release();
+	}
+
+	static const WCHAR msc_fontName[] = L"Verdana";
+	static const FLOAT msc_fontSize = 20;
+
+	IDWriteTextFormat* textFormat = NULL;
+
+	// Create a DirectWrite text format object.
+	pDWriteFactory->CreateTextFormat(
+		msc_fontName,
+		NULL,
+		DWRITE_FONT_WEIGHT_NORMAL,
+		DWRITE_FONT_STYLE_NORMAL,
+		DWRITE_FONT_STRETCH_NORMAL,
+		msc_fontSize,
+		L"", //locale
+		&textFormat
+		);
+
+	D2D1_SIZE_F renderTargetSize = pRT->GetSize();
+
+	Array<TextPlot>::Iterator textIt;
+	for( textIt = currentFrame->textLines.Begin(); textIt != currentFrame->textLines.End(); ++textIt )
+	{
+		ID2D1SolidColorBrush* aBrush;
+
+		pRT->CreateSolidColorBrush( D2D1::ColorF( textIt->r, textIt->g, textIt->b), &aBrush );
+
+		WCHAR* tmpString = (WCHAR*)calloc( textIt->text.GetLength(),  sizeof( WCHAR ) );
+		for( unsigned i = 0; i < textIt->text.GetLength(); ++i )
+		{
+			tmpString[i] = (WCHAR)textIt->text.GetCharAt( i );
+		}
+					
+		pRT->DrawText( tmpString, (UINT32)textIt->text.GetLength(), textFormat,
+			D2D1::RectF(textIt->x, textIt->y, renderTargetSize.width, renderTargetSize.height), aBrush );
+
+		free( tmpString );
+
+		aBrush->Release();
+	}
+
+	if( textFormat )
+		textFormat->Release();
+
+	pRT->EndDraw();
+
+	pRT->Flush();
+}
+
+Ptr<Frame> ImageWindow::lastUnreadyFrame()
+{
+	static int framenumber = 0;
+
+	if( frames.GetSize() && !frames.PeekBack( 0 )->ready )
+		return frames.PeekBack( 0 );
+
+	// Create a new frame if an unready one doesn't already exist
+	Ptr<Frame> tmpFrame = *new Frame( framenumber );
+	frames.PushBack( tmpFrame );
+
+	++framenumber;
+
+	return tmpFrame;
+}
+
+void ImageWindow::UpdateImageBW( const uint8_t* imageData, uint32_t width, uint32_t height )
+{
+	if( pRT && greyBitmap )
+	{
+		Mutex::Locker locker( frontBufferMutex );
+
+		Ptr<Frame> frame = lastUnreadyFrame();
+		frame->imageData = malloc( width * height );
+		frame->width = width;
+		frame->height = height;
+		memcpy( frame->imageData, imageData, width * height );
+	}
+}
+
+void ImageWindow::UpdateImageRGBA( const uint8_t* imageData, uint32_t width, uint32_t height, uint32_t pitch )
+{
+	if( pRT && colorBitmap )
+	{
+		Mutex::Locker locker( frontBufferMutex );
+
+		Ptr<Frame> frame = lastUnreadyFrame();
+		frame->colorImageData = malloc( pitch * height );
+		frame->width = width;
+		frame->height = height;
+		frame->colorPitch = pitch;
+		memcpy( frame->colorImageData, imageData, pitch * height );
+	}
+}
+
+void ImageWindow::addCircle( float x, float y, float radius, float r, float g, float b, bool fill )
+{
+	if( pRT )
+	{
+		CirclePlot cp;
+
+		cp.x = x;
+		cp.y = y;
+		cp.radius = radius;
+		cp.r = r;
+		cp.g = g;
+		cp.b = b;
+		cp.fill = fill;
+
+		Mutex::Locker locker( frontBufferMutex );
+
+		Ptr<Frame> frame = lastUnreadyFrame();
+		frame->plots.PushBack( cp );
+	}
+
+}
+
+void ImageWindow::addText( float x, float y, float r, float g, float b, OVR::String text )
+{
+	if( pRT )
+	{
+		TextPlot tp;
+
+		tp.x = x;
+		tp.y = y;
+		tp.r = r;
+		tp.g = g;
+		tp.b = b;
+		tp.text = text;
+
+		Mutex::Locker locker( frontBufferMutex );
+		Ptr<Frame> frame = lastUnreadyFrame();
+		frame->textLines.PushBack( tp );
+	}
+}
+
+}}
+
+#else //defined(OVR_OS_WIN32)
+
+namespace OVR { namespace Util {
+
+ImageWindow* ImageWindow::globalWindow[4];
+int ImageWindow::windowCount = 0;
+
+}}
+
+#endif //#else //defined(OVR_OS_WIN32)
+