From e0c0e83fd5534b24f18d5e02a453182df54933e0 Mon Sep 17 00:00:00 2001 From: Jason Barron Date: Mon, 15 Oct 2012 14:16:51 +0200 Subject: Add ANGLE as a 3rdparty library to Qt. ANGLE is a component that implements the OpenGL ES 2.0 API on top of DirectX 9. See the following for more info: http://code.google.com/p/angleproject/ ANGLE is now the default configuration on Windows. If you want to use desktop OpenGL, you should build Qt with the following configure options: -opengl desktop To configure Qt to use another OpenGL ES 2 implementation, you should use: -opengl es2 -no-angle Task-number: QTBUG-24207 Change-Id: Iefcbeaa37ed920f431729749ab8333b248fe5134 Reviewed-by: Friedemann Kleint --- src/3rdparty/angle/src/common/RefCountObject.cpp | 47 ++++++++++ src/3rdparty/angle/src/common/RefCountObject.h | 65 ++++++++++++++ src/3rdparty/angle/src/common/angleutils.h | 26 ++++++ src/3rdparty/angle/src/common/debug.cpp | 103 ++++++++++++++++++++++ src/3rdparty/angle/src/common/debug.h | 105 +++++++++++++++++++++++ src/3rdparty/angle/src/common/version.h | 10 +++ 6 files changed, 356 insertions(+) create mode 100644 src/3rdparty/angle/src/common/RefCountObject.cpp create mode 100644 src/3rdparty/angle/src/common/RefCountObject.h create mode 100644 src/3rdparty/angle/src/common/angleutils.h create mode 100644 src/3rdparty/angle/src/common/debug.cpp create mode 100644 src/3rdparty/angle/src/common/debug.h create mode 100644 src/3rdparty/angle/src/common/version.h (limited to 'src/3rdparty/angle/src/common') diff --git a/src/3rdparty/angle/src/common/RefCountObject.cpp b/src/3rdparty/angle/src/common/RefCountObject.cpp new file mode 100644 index 0000000000..c1ef90cdcc --- /dev/null +++ b/src/3rdparty/angle/src/common/RefCountObject.cpp @@ -0,0 +1,47 @@ +// +// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RefCountObject.cpp: Defines the gl::RefCountObject base class that provides +// lifecycle support for GL objects using the traditional BindObject scheme, but +// that need to be reference counted for correct cross-context deletion. +// (Concretely, textures, buffers and renderbuffers.) + +#include "RefCountObject.h" + +RefCountObject::RefCountObject(GLuint id) +{ + mId = id; + mRefCount = 0; +} + +RefCountObject::~RefCountObject() +{ + ASSERT(mRefCount == 0); +} + +void RefCountObject::addRef() const +{ + mRefCount++; +} + +void RefCountObject::release() const +{ + ASSERT(mRefCount > 0); + + if (--mRefCount == 0) + { + delete this; + } +} + +void RefCountObjectBindingPointer::set(RefCountObject *newObject) +{ + // addRef first in case newObject == mObject and this is the last reference to it. + if (newObject != NULL) newObject->addRef(); + if (mObject != NULL) mObject->release(); + + mObject = newObject; +} diff --git a/src/3rdparty/angle/src/common/RefCountObject.h b/src/3rdparty/angle/src/common/RefCountObject.h new file mode 100644 index 0000000000..727c71c362 --- /dev/null +++ b/src/3rdparty/angle/src/common/RefCountObject.h @@ -0,0 +1,65 @@ +// +// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RefCountObject.h: Defines the gl::RefCountObject base class that provides +// lifecycle support for GL objects using the traditional BindObject scheme, but +// that need to be reference counted for correct cross-context deletion. +// (Concretely, textures, buffers and renderbuffers.) + +#ifndef COMMON_REFCOUNTOBJECT_H_ +#define COMMON_REFCOUNTOBJECT_H_ + +#include + +#define GL_APICALL +#include + +#include "common/debug.h" + +class RefCountObject +{ + public: + explicit RefCountObject(GLuint id); + virtual ~RefCountObject(); + + virtual void addRef() const; + virtual void release() const; + + GLuint id() const { return mId; } + + private: + GLuint mId; + + mutable std::size_t mRefCount; +}; + +class RefCountObjectBindingPointer +{ + protected: + RefCountObjectBindingPointer() : mObject(NULL) { } + ~RefCountObjectBindingPointer() { ASSERT(mObject == NULL); } // Objects have to be released before the resource manager is destroyed, so they must be explicitly cleaned up. + + void set(RefCountObject *newObject); + RefCountObject *get() const { return mObject; } + + public: + GLuint id() const { return (mObject != NULL) ? mObject->id() : 0; } + bool operator ! () const { return (get() == NULL); } + + private: + RefCountObject *mObject; +}; + +template +class BindingPointer : public RefCountObjectBindingPointer +{ + public: + void set(ObjectType *newObject) { RefCountObjectBindingPointer::set(newObject); } + ObjectType *get() const { return static_cast(RefCountObjectBindingPointer::get()); } + ObjectType *operator -> () const { return get(); } +}; + +#endif // COMMON_REFCOUNTOBJECT_H_ diff --git a/src/3rdparty/angle/src/common/angleutils.h b/src/3rdparty/angle/src/common/angleutils.h new file mode 100644 index 0000000000..ff9730c4da --- /dev/null +++ b/src/3rdparty/angle/src/common/angleutils.h @@ -0,0 +1,26 @@ +// +// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// angleutils.h: Common ANGLE utilities. + +#ifndef COMMON_ANGLEUTILS_H_ +#define COMMON_ANGLEUTILS_H_ + +// A macro to disallow the copy constructor and operator= functions +// This must be used in the private: declarations for a class +#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&); \ + void operator=(const TypeName&) + +#if defined(_MSC_VER) +#define snprintf _snprintf +#endif + +#define VENDOR_ID_AMD 0x1002 +#define VENDOR_ID_INTEL 0x8086 +#define VENDOR_ID_NVIDIA 0x10DE + +#endif // COMMON_ANGLEUTILS_H_ diff --git a/src/3rdparty/angle/src/common/debug.cpp b/src/3rdparty/angle/src/common/debug.cpp new file mode 100644 index 0000000000..b2238f9708 --- /dev/null +++ b/src/3rdparty/angle/src/common/debug.cpp @@ -0,0 +1,103 @@ +// +// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// debug.cpp: Debugging utilities. + +#include "common/debug.h" + +#include +#include +#include +#include + +namespace gl +{ + +typedef void (WINAPI *PerfOutputFunction)(D3DCOLOR, LPCWSTR); + +static void output(bool traceFileDebugOnly, PerfOutputFunction perfFunc, const char *format, va_list vararg) +{ +#if !defined(ANGLE_DISABLE_PERF) + if (perfActive()) + { + char message[32768]; + int len = vsprintf_s(message, format, vararg); + if (len < 0) + { + return; + } + + // There are no ASCII variants of these D3DPERF functions. + wchar_t wideMessage[32768]; + for (int i = 0; i < len; ++i) + { + wideMessage[i] = message[i]; + } + wideMessage[len] = 0; + + perfFunc(0, wideMessage); + } +#endif + +#if !defined(ANGLE_DISABLE_TRACE) +#if defined(NDEBUG) + if (traceFileDebugOnly) + { + return; + } +#endif + + FILE* file = fopen(TRACE_OUTPUT_FILE, "a"); + if (file) + { + vfprintf(file, format, vararg); + fclose(file); + } +#endif +} + +void trace(bool traceFileDebugOnly, const char *format, ...) +{ + va_list vararg; + va_start(vararg, format); +#if defined(ANGLE_DISABLE_PERF) + output(traceFileDebugOnly, NULL, format, vararg); +#else + output(traceFileDebugOnly, D3DPERF_SetMarker, format, vararg); +#endif + va_end(vararg); +} + +bool perfActive() +{ +#if defined(ANGLE_DISABLE_PERF) + return false; +#else + static bool active = D3DPERF_GetStatus() != 0; + return active; +#endif +} + +ScopedPerfEventHelper::ScopedPerfEventHelper(const char* format, ...) +{ +#if !defined(ANGLE_DISABLE_PERF) + va_list vararg; + va_start(vararg, format); + output(true, reinterpret_cast(D3DPERF_BeginEvent), format, vararg); + va_end(vararg); +#endif +} + +ScopedPerfEventHelper::~ScopedPerfEventHelper() +{ +#if !defined(ANGLE_DISABLE_PERF) + if (perfActive()) + { + D3DPERF_EndEvent(); + } +#endif +} +} diff --git a/src/3rdparty/angle/src/common/debug.h b/src/3rdparty/angle/src/common/debug.h new file mode 100644 index 0000000000..5f8f60fe61 --- /dev/null +++ b/src/3rdparty/angle/src/common/debug.h @@ -0,0 +1,105 @@ +// +// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// debug.h: Debugging utilities. + +#ifndef COMMON_DEBUG_H_ +#define COMMON_DEBUG_H_ + +#include +#include + +#include "common/angleutils.h" + +#if !defined(TRACE_OUTPUT_FILE) +#define TRACE_OUTPUT_FILE "debug.txt" +#endif + +namespace gl +{ + // Outputs text to the debugging log + void trace(bool traceFileDebugOnly, const char *format, ...); + + // Returns whether D3DPERF is active. + bool perfActive(); + + // Pairs a D3D begin event with an end event. + class ScopedPerfEventHelper + { + public: + ScopedPerfEventHelper(const char* format, ...); + ~ScopedPerfEventHelper(); + + private: + DISALLOW_COPY_AND_ASSIGN(ScopedPerfEventHelper); + }; +} + +// A macro to output a trace of a function call and its arguments to the debugging log +#if defined(ANGLE_DISABLE_TRACE) && defined(ANGLE_DISABLE_PERF) +#define TRACE(message, ...) (void(0)) +#else +#define TRACE(message, ...) gl::trace(true, "trace: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__) +#endif + +// A macro to output a function call and its arguments to the debugging log, to denote an item in need of fixing. +#if defined(ANGLE_DISABLE_TRACE) && defined(ANGLE_DISABLE_PERF) +#define FIXME(message, ...) (void(0)) +#else +#define FIXME(message, ...) gl::trace(false, "fixme: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__) +#endif + +// A macro to output a function call and its arguments to the debugging log, in case of error. +#if defined(ANGLE_DISABLE_TRACE) && defined(ANGLE_DISABLE_PERF) +#define ERR(message, ...) (void(0)) +#else +#define ERR(message, ...) gl::trace(false, "err: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__) +#endif + +// A macro to log a performance event around a scope. +#if defined(ANGLE_DISABLE_TRACE) && defined(ANGLE_DISABLE_PERF) +#define EVENT(message, ...) (void(0)) +#elif defined(_MSC_VER) +#define EVENT(message, ...) gl::ScopedPerfEventHelper scopedPerfEventHelper ## __LINE__(__FUNCTION__ message "\n", __VA_ARGS__); +#else +#define EVENT(message, ...) gl::ScopedPerfEventHelper scopedPerfEventHelper(message "\n", ##__VA_ARGS__); +#endif + +// A macro asserting a condition and outputting failures to the debug log +#if !defined(NDEBUG) +#define ASSERT(expression) do { \ + if(!(expression)) \ + ERR("\t! Assert failed in %s(%d): "#expression"\n", __FUNCTION__, __LINE__); \ + assert(expression); \ + } while(0) +#else +#define ASSERT(expression) (void(0)) +#endif + +// A macro to indicate unimplemented functionality +#if !defined(NDEBUG) +#define UNIMPLEMENTED() do { \ + FIXME("\t! Unimplemented: %s(%d)\n", __FUNCTION__, __LINE__); \ + assert(false); \ + } while(0) +#else + #define UNIMPLEMENTED() FIXME("\t! Unimplemented: %s(%d)\n", __FUNCTION__, __LINE__) +#endif + +// A macro for code which is not expected to be reached under valid assumptions +#if !defined(NDEBUG) +#define UNREACHABLE() do { \ + ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__); \ + assert(false); \ + } while(0) +#else + #define UNREACHABLE() ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__) +#endif + +// A macro functioning as a compile-time assert to validate constant conditions +#define META_ASSERT(condition) typedef int COMPILE_TIME_ASSERT_##__LINE__[static_cast(condition)?1:-1] + +#endif // COMMON_DEBUG_H_ diff --git a/src/3rdparty/angle/src/common/version.h b/src/3rdparty/angle/src/common/version.h new file mode 100644 index 0000000000..fec98a15c9 --- /dev/null +++ b/src/3rdparty/angle/src/common/version.h @@ -0,0 +1,10 @@ +#define MAJOR_VERSION 1 +#define MINOR_VERSION 0 +#define BUILD_VERSION 0 +#define BUILD_REVISION 1318 + +#define STRINGIFY(x) #x +#define MACRO_STRINGIFY(x) STRINGIFY(x) + +#define REVISION_STRING MACRO_STRINGIFY(BUILD_REVISION) +#define VERSION_STRING MACRO_STRINGIFY(MAJOR_VERSION) "." MACRO_STRINGIFY(MINOR_VERSION) "." MACRO_STRINGIFY(BUILD_VERSION) "." MACRO_STRINGIFY(BUILD_REVISION) -- cgit v1.2.3