From c44eaa4144064c0ca51d653bddd2583f9f41d51e Mon Sep 17 00:00:00 2001 From: Chinmay Garde Date: Tue, 21 Jul 2015 10:17:50 -0700 Subject: [PATCH 01/11] Extract and reuse common sky/shell components on Mac and iOS --- sky/shell/BUILD.gn | 73 +- sky/shell/ios/main_ios.mm | 61 +- sky/shell/ios/sky_app_delegate.mm | 34 +- sky/shell/ios/sky_surface.mm | 6 +- sky/shell/mac/.gitignore | 26 + sky/shell/mac/Info.plist | 34 + sky/shell/mac/main_mac.mm | 83 +++ sky/shell/mac/platform_mac.h | 21 + sky/shell/mac/platform_mac.mm | 85 +++ .../platform_service_provider_mac.cc} | 0 .../platform_view_mac.h} | 14 +- .../platform_view_mac.mm} | 12 +- sky/shell/mac/sky_app_delegate.h | 10 + sky/shell/mac/sky_app_delegate.m | 15 + sky/shell/mac/sky_mac.xib | 695 ++++++++++++++++++ sky/shell/mac/sky_window.h | 9 + sky/shell/mac/sky_window.mm | 113 +++ ui/gl/gl_surface_mac.cc | 191 ++--- ui/gl/gl_surface_mac.h | 29 + 19 files changed, 1263 insertions(+), 248 deletions(-) create mode 100644 sky/shell/mac/.gitignore create mode 100644 sky/shell/mac/Info.plist create mode 100644 sky/shell/mac/main_mac.mm create mode 100644 sky/shell/mac/platform_mac.h create mode 100644 sky/shell/mac/platform_mac.mm rename sky/shell/{ios/platform_service_provider_ios.cc => mac/platform_service_provider_mac.cc} (100%) rename sky/shell/{ios/platform_view_ios.h => mac/platform_view_mac.h} (57%) rename sky/shell/{ios/platform_view_ios.mm => mac/platform_view_mac.mm} (62%) create mode 100644 sky/shell/mac/sky_app_delegate.h create mode 100644 sky/shell/mac/sky_app_delegate.m create mode 100644 sky/shell/mac/sky_mac.xib create mode 100644 sky/shell/mac/sky_window.h create mode 100644 sky/shell/mac/sky_window.mm create mode 100644 ui/gl/gl_surface_mac.h diff --git a/sky/shell/BUILD.gn b/sky/shell/BUILD.gn index ae169d3a4e8..ac847120abd 100644 --- a/sky/shell/BUILD.gn +++ b/sky/shell/BUILD.gn @@ -158,9 +158,6 @@ if (is_android) { source_set(scaffolding_target) { sources = [ "ios/main_ios.mm", - "ios/platform_service_provider_ios.cc", - "ios/platform_view_ios.h", - "ios/platform_view_ios.mm", "ios/sky_app_delegate.h", "ios/sky_app_delegate.mm", "ios/sky_surface.h", @@ -169,10 +166,20 @@ if (is_android) { "ios/sky_view_controller.mm", ] + set_sources_assignment_filter([]) + sources += [ + "mac/platform_mac.h", + "mac/platform_mac.mm", + "mac/platform_service_provider_mac.cc", + "mac/platform_view_mac.h", + "mac/platform_view_mac.mm", + ] + set_sources_assignment_filter(sources_assignment_filter) + deps = common_deps + [ - ":common", - "//sky/services/ns_net", - ] + ":common", + "//sky/services/ns_net", + ] } deps = [ @@ -193,9 +200,57 @@ if (is_android) { ] deps = common_deps + [ - ":common", - "//sky/services/testing:interfaces", - ] + ":common", + "//sky/services/testing:interfaces", + ] + } +} else if (is_mac) { + import("//build/config/mac/rules.gni") + + mac_app("shell") { + app_name = "Sky" + info_plist = "mac/Info.plist" + scaffolding_target = "mac_scaffolding" + + # entitlements_path = "" + # code_signing_identity = "" + + xibs = [ + "mac/sky_mac.xib" + ] + + resource_copy_mac("sky_resources") { + resources = [ "//third_party/icu/android/icudtl.dat" ] + bundle_directory = "." + } + + source_set(scaffolding_target) { + sources = [ + "mac/main_mac.mm", + "mac/platform_mac.h", + "mac/platform_mac.mm", + "mac/platform_service_provider_mac.cc", + "mac/platform_view_mac.h", + "mac/platform_view_mac.mm", + "mac/sky_app_delegate.h", + "mac/sky_app_delegate.m", + "mac/sky_window.h", + "mac/sky_window.mm", + "testing/test_runner.cc", + "testing/test_runner.h", + ] + + deps = common_deps + [ + ":common", + "//sky/services/ns_net", + "//sky/services/testing:interfaces", + ] + } + + deps = [ + ":$scaffolding_target", + ":sky_resources", + ] } } else { assert(false, "Unsupported platform") diff --git a/sky/shell/ios/main_ios.mm b/sky/shell/ios/main_ios.mm index b0eb2042a8a..524b89f5b9a 100644 --- a/sky/shell/ios/main_ios.mm +++ b/sky/shell/ios/main_ios.mm @@ -3,14 +3,9 @@ // found in the LICENSE file. #import -#include -#import "sky_app_delegate.h" -#include "base/at_exit.h" -#include "base/logging.h" -#include "base/i18n/icu_util.h" -#include "base/command_line.h" -#include "base/mac/scoped_nsautorelease_pool.h" -#include "ui/gl/gl_surface.h" +#import "sky/shell/ios/sky_app_delegate.h" + +#include "sky/shell/mac/platform_mac.h" extern "C" { // TODO(csg): HACK! boringssl accesses this on Android using a weak symbol @@ -22,49 +17,9 @@ unsigned long getauxval(unsigned long type) { } } -static void InitializeLogging() { - logging::LoggingSettings settings; - settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG; - logging::InitLogging(settings); - logging::SetLogItems(false, // Process ID - false, // Thread ID - false, // Timestamp - false); // Tick count -} - -static void RedirectIOConnectionsToSyslog() { - asl_log_descriptor(NULL, NULL, ASL_LEVEL_INFO, STDOUT_FILENO, - ASL_LOG_DESCRIPTOR_WRITE); - asl_log_descriptor(NULL, NULL, ASL_LEVEL_NOTICE, STDERR_FILENO, - ASL_LOG_DESCRIPTOR_WRITE); -} - -#ifndef NDEBUG - -static void SkyDebuggerHookMain(void) { - // By default, LLDB breaks way too early. This is before libraries have been - // loaded and __attribute__((constructor)) methods have been called. In most - // situations, this is unnecessary. Also, breakpoint resolution is not - // immediate. So we provide this hook to break on. -} - -#endif - -int main(int argc, char* argv[]) { -#ifndef NDEBUG - SkyDebuggerHookMain(); -#endif - base::mac::ScopedNSAutoreleasePool pool; - base::AtExitManager exit_manager; - RedirectIOConnectionsToSyslog(); - auto result = false; - result = base::CommandLine::Init(0, nullptr); - DLOG_ASSERT(result); - InitializeLogging(); - result = base::i18n::InitializeICU(); - DLOG_ASSERT(result); - result = gfx::GLSurface::InitializeOneOff(); - DLOG_ASSERT(result); - return UIApplicationMain(argc, argv, nil, - NSStringFromClass([SkyAppDelegate class])); +int main(int argc, const char * argv[]) { + return PlatformMacMain(argc, argv, ^(){ + return UIApplicationMain(argc, (char **)argv, nil, + NSStringFromClass([SkyAppDelegate class])); + }); } diff --git a/sky/shell/ios/sky_app_delegate.mm b/sky/shell/ios/sky_app_delegate.mm index ff7449daaa9..add0a0dc4a8 100644 --- a/sky/shell/ios/sky_app_delegate.mm +++ b/sky/shell/ios/sky_app_delegate.mm @@ -5,41 +5,11 @@ #import "sky_app_delegate.h" #import "sky_view_controller.h" -#include "sky/shell/shell.h" -#include "sky/shell/service_provider.h" -#include "sky/shell/ui_delegate.h" -#include "base/lazy_instance.h" -#include "base/message_loop/message_loop.h" - -@implementation SkyAppDelegate { - base::LazyInstance> _main_message_loop; -} +@implementation SkyAppDelegate - (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions { - [self setupSkyShell]; - [self setupViewport]; - return YES; -} - -- (void)setupSkyShell { - [self adoptPlatformRunLoop]; - - auto service_provider_context = - make_scoped_ptr(new sky::shell::ServiceProviderContext( - _main_message_loop.Get()->task_runner())); - sky::shell::Shell::Init(service_provider_context.Pass()); -} - -- (void)adoptPlatformRunLoop { - _main_message_loop.Get().reset(new base::MessageLoopForUI); - // One cannot start the message loop on the platform main thread. Instead, - // we attach to the CFRunLoop - base::MessageLoopForUI::current()->Attach(); -} - -- (void)setupViewport { CGRect frame = [UIScreen mainScreen].bounds; UIWindow* window = [[UIWindow alloc] initWithFrame:frame]; SkyViewController* viewController = [[SkyViewController alloc] init]; @@ -48,6 +18,8 @@ self.window = window; [window release]; [self.window makeKeyAndVisible]; + + return YES; } @end diff --git a/sky/shell/ios/sky_surface.mm b/sky/shell/ios/sky_surface.mm index f63aa5492f7..b33a063deaf 100644 --- a/sky/shell/ios/sky_surface.mm +++ b/sky/shell/ios/sky_surface.mm @@ -11,7 +11,7 @@ #include "base/time/time.h" #include "mojo/public/cpp/bindings/interface_request.h" #include "sky/services/engine/input_event.mojom.h" -#include "sky/shell/ios/platform_view_ios.h" +#include "sky/shell/mac/platform_view_mac.h" #include "sky/shell/shell_view.h" #include "sky/shell/shell.h" #include "sky/shell/ui_delegate.h" @@ -114,8 +114,8 @@ static sky::InputEventPtr BasicInputEventFromRecognizer( [self connectToEngineAndLoad]; } -- (sky::shell::PlatformViewIOS*)platformView { - auto view = static_cast(_shell_view->view()); +- (sky::shell::PlatformViewMac*)platformView { + auto view = static_cast(_shell_view->view()); DCHECK(view); return view; } diff --git a/sky/shell/mac/.gitignore b/sky/shell/mac/.gitignore new file mode 100644 index 00000000000..962db51bbdb --- /dev/null +++ b/sky/shell/mac/.gitignore @@ -0,0 +1,26 @@ +.idea/ +.sconsign.dblite +.svn/ + +.DS_Store +*.swp +*.lock +profile + +DerivedData/ +build/ + +*.pbxuser +*.mode1v3 +*.mode2v3 +*.perspectivev3 + +!default.pbxuser +!default.mode1v3 +!default.mode2v3 +!default.perspectivev3 + +xcuserdata + +*.moved-aside +Sky.xcodeproj/ diff --git a/sky/shell/mac/Info.plist b/sky/shell/mac/Info.plist new file mode 100644 index 00000000000..3e73f37a075 --- /dev/null +++ b/sky/shell/mac/Info.plist @@ -0,0 +1,34 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + Sky + CFBundleIconFile + + CFBundleIdentifier + org.domokit.sky + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + Sky + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + LSMinimumSystemVersion + 10.6 + NSHumanReadableCopyright + Copyright © 2015 The Chromium Authors. All rights reserved. + NSMainNibFile + sky_mac + NSPrincipalClass + NSApplication + + diff --git a/sky/shell/mac/main_mac.mm b/sky/shell/mac/main_mac.mm new file mode 100644 index 00000000000..a6db5790343 --- /dev/null +++ b/sky/shell/mac/main_mac.mm @@ -0,0 +1,83 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#import +#include +#include "base/bind.h" +#include "base/message_loop/message_loop.h" +#include "sky/engine/public/web/WebRuntimeFeatures.h" +#include "sky/shell/mac/platform_mac.h" +#include "base/command_line.h" +#include "sky/shell/switches.h" +#include "sky/shell/testing/test_runner.h" + +namespace sky { +namespace shell { +namespace { + +bool FlagsValid() { + base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess(); + + if (command_line.HasSwitch(sky::shell::switches::kHelp) || + (!command_line.HasSwitch(sky::shell::switches::kPackageRoot) && + !command_line.HasSwitch(sky::shell::switches::kSnapshot))) { + return false; + } + + return true; +} + +void Usage() { + std::cerr << "(For Test Shell) Usage: sky_shell" + << " --" << switches::kNonInteractive + << " --" << switches::kPackageRoot << "=PACKAGE_ROOT" + << " --" << switches::kSnapshot << "=SNAPSHOT" + << " [ MAIN_DART ]" << std::endl; +} + +void Init() { + base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess(); + blink::WebRuntimeFeatures::enableObservatory( + !command_line.HasSwitch(switches::kNonInteractive)); + + // Explicitly boot the shared test runner. + TestRunner& runner = TestRunner::Shared(); + + std::string package_root = + command_line.GetSwitchValueASCII(switches::kPackageRoot); + runner.set_package_root(package_root); + + scoped_ptr single_test; + if (command_line.HasSwitch(switches::kSnapshot)) { + single_test.reset(new TestRunner::SingleTest); + single_test->path = command_line.GetSwitchValueASCII(switches::kSnapshot); + single_test->is_snapshot = true; + } else { + auto args = command_line.GetArgs(); + if (!args.empty()) { + single_test.reset(new TestRunner::SingleTest); + single_test->path = args[0]; + } + } + + runner.Start(single_test.Pass()); +} + +} // namespace +} // namespace shell +} // namespace sky + +int main(int argc, const char * argv[]) { + return PlatformMacMain(argc, argv, ^(){ + if (!sky::shell::FlagsValid()) { + sky::shell::Usage(); + return NSApplicationMain(argc, argv); + } else { + auto loop = base::MessageLoop::current(); + loop->PostTask(FROM_HERE, base::Bind(&sky::shell::Init)); + loop->Run(); + return EXIT_SUCCESS; + } + }); +} diff --git a/sky/shell/mac/platform_mac.h b/sky/shell/mac/platform_mac.h new file mode 100644 index 00000000000..25a479aa346 --- /dev/null +++ b/sky/shell/mac/platform_mac.h @@ -0,0 +1,21 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SKY_SHELL_MAC_PLATFORM_MAC_H_ +#define SKY_SHELL_MAC_PLATFORM_MAC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int(^PlatformMacMainCallback)(void); + +int PlatformMacMain(int argc, const char *argv[], + PlatformMacMainCallback callback); + +#ifdef __cplusplus +} +#endif + +#endif // SKY_SHELL_MAC_PLATFORM_MAC_H_ diff --git a/sky/shell/mac/platform_mac.mm b/sky/shell/mac/platform_mac.mm new file mode 100644 index 00000000000..2ba18ed2c1a --- /dev/null +++ b/sky/shell/mac/platform_mac.mm @@ -0,0 +1,85 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sky/shell/mac/platform_mac.h" + +#include +#include "base/at_exit.h" +#include "base/logging.h" +#include "base/i18n/icu_util.h" +#include "base/command_line.h" +#include "base/mac/scoped_nsautorelease_pool.h" +#include "ui/gl/gl_surface.h" +#include "sky/shell/shell.h" +#include "sky/shell/service_provider.h" +#include "sky/shell/ui_delegate.h" +#include "base/lazy_instance.h" +#include "base/message_loop/message_loop.h" + +static void InitializeLogging() { + logging::LoggingSettings settings; + settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG; + logging::InitLogging(settings); + logging::SetLogItems(false, // Process ID + false, // Thread ID + false, // Timestamp + false); // Tick count +} + +static void RedirectIOConnectionsToSyslog() { +#if TARGET_OS_IPHONE + asl_log_descriptor(NULL, NULL, ASL_LEVEL_INFO, STDOUT_FILENO, + ASL_LOG_DESCRIPTOR_WRITE); + asl_log_descriptor(NULL, NULL, ASL_LEVEL_NOTICE, STDERR_FILENO, + ASL_LOG_DESCRIPTOR_WRITE); +#endif +} + +int PlatformMacMain(int argc, const char *argv[], + PlatformMacMainCallback callback) { + + base::mac::ScopedNSAutoreleasePool pool; + + base::AtExitManager exit_manager; + + RedirectIOConnectionsToSyslog(); + + auto result = false; + + result = base::CommandLine::Init(argc, argv); + DLOG_ASSERT(result); + + InitializeLogging(); + + result = base::i18n::InitializeICU(); + DLOG_ASSERT(result); + + result = gfx::GLSurface::InitializeOneOff(); + DLOG_ASSERT(result); + + scoped_ptr main_message_loop( + new base::MessageLoopForUI()); + +#if TARGET_OS_IPHONE + // One cannot start the message loop on the platform main thread. Instead, + // we attach to the CFRunLoop + main_message_loop->Attach(); +#endif + + auto service_provider_context = + make_scoped_ptr(new sky::shell::ServiceProviderContext( + main_message_loop->task_runner())); + + sky::shell::Shell::Init(service_provider_context.Pass()); + + result = callback(); + +#if !TARGET_OS_IPHONE + if (result == EXIT_SUCCESS) { + main_message_loop->QuitNow(); + } +#endif + + return result; +} diff --git a/sky/shell/ios/platform_service_provider_ios.cc b/sky/shell/mac/platform_service_provider_mac.cc similarity index 100% rename from sky/shell/ios/platform_service_provider_ios.cc rename to sky/shell/mac/platform_service_provider_mac.cc diff --git a/sky/shell/ios/platform_view_ios.h b/sky/shell/mac/platform_view_mac.h similarity index 57% rename from sky/shell/ios/platform_view_ios.h rename to sky/shell/mac/platform_view_mac.h index a9e1ef6ffcf..d5fe68f731b 100644 --- a/sky/shell/ios/platform_view_ios.h +++ b/sky/shell/mac/platform_view_mac.h @@ -2,26 +2,26 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef SKY_SHELL_PLATFORM_VIEW_IOS_H_ -#define SKY_SHELL_PLATFORM_VIEW_IOS_H_ +#ifndef SKY_SHELL_PLATFORM_VIEW_MAC_H_ +#define SKY_SHELL_PLATFORM_VIEW_MAC_H_ #include "sky/shell/platform_view.h" namespace sky { namespace shell { -class PlatformViewIOS : public PlatformView { +class PlatformViewMac : public PlatformView { public: - explicit PlatformViewIOS(const Config& config); - ~PlatformViewIOS() override; + explicit PlatformViewMac(const Config& config); + ~PlatformViewMac() override; void SurfaceCreated(gfx::AcceleratedWidget widget); void SurfaceDestroyed(void); private: - DISALLOW_COPY_AND_ASSIGN(PlatformViewIOS); + DISALLOW_COPY_AND_ASSIGN(PlatformViewMac); }; } // namespace shell } // namespace sky -#endif // SKY_SHELL_PLATFORM_VIEW_IOS_H_ +#endif // SKY_SHELL_PLATFORM_VIEW_MAC_H_ diff --git a/sky/shell/ios/platform_view_ios.mm b/sky/shell/mac/platform_view_mac.mm similarity index 62% rename from sky/shell/ios/platform_view_ios.mm rename to sky/shell/mac/platform_view_mac.mm index 3c5f90d1607..459cbad8860 100644 --- a/sky/shell/ios/platform_view_ios.mm +++ b/sky/shell/mac/platform_view_mac.mm @@ -2,29 +2,29 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "platform_view_ios.h" +#include "sky/shell/mac/platform_view_mac.h" namespace sky { namespace shell { PlatformView* PlatformView::Create(const Config& config) { - return new PlatformViewIOS(config); + return new PlatformViewMac(config); } -PlatformViewIOS::PlatformViewIOS(const Config& config) +PlatformViewMac::PlatformViewMac(const Config& config) : PlatformView(config) { } -PlatformViewIOS::~PlatformViewIOS() { +PlatformViewMac::~PlatformViewMac() { } -void PlatformViewIOS::SurfaceCreated(gfx::AcceleratedWidget widget) { +void PlatformViewMac::SurfaceCreated(gfx::AcceleratedWidget widget) { DCHECK(window_ == 0); window_ = widget; SurfaceWasCreated(); } -void PlatformViewIOS::SurfaceDestroyed() { +void PlatformViewMac::SurfaceDestroyed() { DCHECK(window_); window_ = 0; SurfaceWasDestroyed(); diff --git a/sky/shell/mac/sky_app_delegate.h b/sky/shell/mac/sky_app_delegate.h new file mode 100644 index 00000000000..6326af00ce9 --- /dev/null +++ b/sky/shell/mac/sky_app_delegate.h @@ -0,0 +1,10 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#import + +@interface SkyAppDelegate : NSObject + +@end + diff --git a/sky/shell/mac/sky_app_delegate.m b/sky/shell/mac/sky_app_delegate.m new file mode 100644 index 00000000000..4a527099828 --- /dev/null +++ b/sky/shell/mac/sky_app_delegate.m @@ -0,0 +1,15 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#import "sky_app_delegate.h" + +@interface SkyAppDelegate () + +@property (assign) IBOutlet NSWindow *window; + +@end + +@implementation SkyAppDelegate + +@end diff --git a/sky/shell/mac/sky_mac.xib b/sky/shell/mac/sky_mac.xib new file mode 100644 index 00000000000..8abc72a57b9 --- /dev/null +++ b/sky/shell/mac/sky_mac.xib @@ -0,0 +1,695 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Default + + + + + + + Left to Right + + + + + + + Right to Left + + + + + + + + + + + Default + + + + + + + Left to Right + + + + + + + Right to Left + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sky/shell/mac/sky_window.h b/sky/shell/mac/sky_window.h new file mode 100644 index 00000000000..07540aba162 --- /dev/null +++ b/sky/shell/mac/sky_window.h @@ -0,0 +1,9 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#import + +@interface SkyWindow : NSWindow + +@end diff --git a/sky/shell/mac/sky_window.mm b/sky/shell/mac/sky_window.mm new file mode 100644 index 00000000000..bcad63cb042 --- /dev/null +++ b/sky/shell/mac/sky_window.mm @@ -0,0 +1,113 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#import "sky_window.h" +#include "base/time/time.h" +#include "mojo/public/cpp/bindings/interface_request.h" +#include "sky/services/engine/input_event.mojom.h" +#include "sky/shell/mac/platform_view_mac.h" +#include "sky/shell/shell_view.h" +#include "sky/shell/shell.h" +#include "sky/shell/ui_delegate.h" + +@interface SkyWindow () + +@property (assign) IBOutlet NSOpenGLView *renderSurface; +@property (getter=isSurfaceSetup) BOOL surfaceSetup; + +@end + +@implementation SkyWindow { + sky::SkyEnginePtr _sky_engine; + scoped_ptr _shell_view; +} + +@synthesize renderSurface=_renderSurface; +@synthesize surfaceSetup=_surfaceSetup; + +-(void) awakeFromNib { + [super awakeFromNib]; + + self.delegate = self; + + [self windowDidResize:nil]; +} + +-(void) setupShell { + NSAssert(_shell_view == nullptr, @"The shell view must not already be set"); + auto shell_view = new sky::shell::ShellView(sky::shell::Shell::Shared()); + _shell_view.reset(shell_view); + + auto widget = reinterpret_cast(self.renderSurface); + self.platformView->SurfaceCreated(widget); +} + +-(NSString *) skyInitialLoadURL { + return @"http://localhost:8080/sky/sdk/example/rendering/simple_autolayout.dart"; +} + +-(void) setupAndLoadDart { + auto interface_request = mojo::GetProxy(&_sky_engine); + self.platformView->ConnectToEngine(interface_request.Pass()); + + mojo::String string(self.skyInitialLoadURL.UTF8String); + _sky_engine->RunFromNetwork(string); +} + +-(void) windowDidResize:(NSNotification *)notification { + [self setupSurfaceIfNecessary]; + + // Resize + + // sky::ViewportMetricsPtr metrics = sky::ViewportMetrics::New(); + // metrics->physical_width = size.width * scale; + // metrics->physical_height = size.height * scale; + // metrics->device_pixel_ratio = scale; + // _sky_engine->OnViewportMetricsChanged(metrics.Pass()); +} + +-(void) setupSurfaceIfNecessary { + if (self.isSurfaceSetup) { + return; + } + + self.surfaceSetup = YES; + + [self setupShell]; + [self setupAndLoadDart]; +} + +- (sky::shell::PlatformViewMac*)platformView { + auto view = static_cast(_shell_view->view()); + DCHECK(view); + return view; +} + +#pragma mark - Responder overrides + +- (void)dispatchEvent:(NSEvent *)event phase:(NSEventPhase) phase { + NSPoint location = [_renderSurface convertPoint:event.locationInWindow + fromView:nil]; + + location.y = _renderSurface.frame.size.height - location.y; +} + +- (void)mouseDown:(NSEvent *)event { + [self dispatchEvent:event phase:NSEventPhaseBegan]; +} + +- (void)mouseDragged:(NSEvent *)event { + [self dispatchEvent:event phase:NSEventPhaseChanged]; +} + +- (void)mouseUp:(NSEvent *)event { + [self dispatchEvent:event phase:NSEventPhaseEnded]; +} + +- (void) dealloc { + self.platformView->SurfaceDestroyed(); + [super dealloc]; +} + +@end diff --git a/ui/gl/gl_surface_mac.cc b/ui/gl/gl_surface_mac.cc index 28a8b8513c0..0686117cd35 100644 --- a/ui/gl/gl_surface_mac.cc +++ b/ui/gl/gl_surface_mac.cc @@ -1,160 +1,73 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2014 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "ui/gl/gl_surface.h" +#include "ui/gl/gl_surface_mac.h" -#include "base/basictypes.h" -#include "base/logging.h" -#include "base/memory/scoped_ptr.h" -#include "base/trace_event/trace_event.h" -#include "ui/gl/gl_bindings.h" +#include "base/mac/scoped_nsautorelease_pool.h" #include "ui/gl/gl_context.h" -#include "ui/gl/gl_implementation.h" -#include "ui/gl/gl_surface_stub.h" -#include "ui/gl/gpu_switching_manager.h" - -#include -#include - -extern "C" { -// The header may not be directly imported since it includes -// gltypes.h which conflict with the types already included -extern CGLError CGLChoosePixelFormat(const CGLPixelFormatAttribute *attribs, - CGLPixelFormatObj *pix, GLint *npix); -extern void CGLReleasePixelFormat(CGLPixelFormatObj pix); -} +#include "ui/gl/gl_enums.h" +#include "base/logging.h" namespace gfx { -namespace { -// A "no-op" surface. It is not required that a CGLContextObj have an -// associated drawable (pbuffer or fullscreen context) in order to be -// made current. Everywhere this surface type is used, we allocate an -// FBO at the user level as the drawable of the associated context. -class GL_EXPORT NoOpGLSurface : public GLSurface { - public: - explicit NoOpGLSurface(const gfx::Size& size, - const gfx::SurfaceConfiguration conf) - : GLSurface(conf), - size_(size) {} - - // Implement GLSurface. - bool Initialize() override { return true; } - void Destroy() override {} - bool IsOffscreen() override { return true; } - bool SwapBuffers() override { - NOTREACHED() << "Cannot call SwapBuffers on a NoOpGLSurface."; - return false; - } - gfx::Size GetSize() override { return size_; } - void* GetHandle() override { return NULL; } - void* GetDisplay() override { return NULL; } - bool IsSurfaceless() const override { return true; } - - protected: - ~NoOpGLSurface() override {} - - private: - gfx::Size size_; - - DISALLOW_COPY_AND_ASSIGN(NoOpGLSurface); -}; - -// static -bool InitializeOneOffForSandbox() { - static bool initialized = false; - if (initialized) - return true; - - // This is called from the sandbox warmup code on Mac OS X. - // GPU-related stuff is very slow without this, probably because - // the sandbox prevents loading graphics drivers or some such. - std::vector attribs; - if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) { - // Avoid switching to the discrete GPU just for this pixel - // format selection. - attribs.push_back(kCGLPFAAllowOfflineRenderers); - } - if (GetGLImplementation() == kGLImplementationAppleGL) { - attribs.push_back(kCGLPFARendererID); - attribs.push_back(static_cast( - kCGLRendererGenericFloatID)); - } - attribs.push_back(static_cast(0)); - - CGLPixelFormatObj format; - GLint num_pixel_formats; - if (CGLChoosePixelFormat(&attribs.front(), - &format, - &num_pixel_formats) != kCGLNoError) { - LOG(ERROR) << "Error choosing pixel format."; - return false; - } - if (!format) { - LOG(ERROR) << "format == 0."; - return false; - } - CGLReleasePixelFormat(format); - DCHECK_NE(num_pixel_formats, 0); - initialized = true; - return true; +GLSurfaceMac::GLSurfaceMac(gfx::AcceleratedWidget widget, + const gfx::SurfaceConfiguration requested_configuration) + : GLSurface(requested_configuration), + widget_(widget) { } -} // namespace +GLSurfaceMac::~GLSurfaceMac() { + Destroy(); +} + +bool GLSurfaceMac::OnMakeCurrent(GLContext* context) { + DCHECK(false); + return false; +} + +bool GLSurfaceMac::SwapBuffers() { + DCHECK(false); + return false; +} + +void GLSurfaceMac::Destroy() { + DCHECK(false); +} + +bool GLSurfaceMac::IsOffscreen() { + DCHECK(false); + return false; +} + +gfx::Size GLSurfaceMac::GetSize() { + DCHECK(false); + return Size(0.0, 0.0); +} + +void* GLSurfaceMac::GetHandle() { + return (void*)widget_; +} bool GLSurface::InitializeOneOffInternal() { - switch (GetGLImplementation()) { - case kGLImplementationDesktopGL: - case kGLImplementationAppleGL: - if (!InitializeOneOffForSandbox()) { - LOG(ERROR) << "GLSurfaceCGL::InitializeOneOff failed."; - return false; - } - break; - default: - break; - } + // On EGL, this method is used to perfom one-time initialization tasks like + // initializing the display, setting up config lists, etc. There is no such + // setup on Mac. return true; } +// static scoped_refptr GLSurface::CreateViewGLSurface( - gfx::AcceleratedWidget window, - const gfx::SurfaceConfiguration& conf) { - TRACE_EVENT0("gpu", "GLSurface::CreateViewGLSurface"); - switch (GetGLImplementation()) { - case kGLImplementationDesktopGL: - case kGLImplementationAppleGL: { - NOTIMPLEMENTED() << "No onscreen support on Mac."; - return NULL; - } - case kGLImplementationMockGL: - return new GLSurfaceStub(conf); - default: - NOTREACHED(); - return NULL; - } -} + gfx::AcceleratedWidget window, + const gfx::SurfaceConfiguration& requested_configuration) { + DCHECK(window != kNullAcceleratedWidget); + scoped_refptr surface = + new GLSurfaceMac(window, requested_configuration); -scoped_refptr GLSurface::CreateOffscreenGLSurface( - const gfx::Size& size, - const gfx::SurfaceConfiguration& conf) { - TRACE_EVENT0("gpu", "GLSurface::CreateOffscreenGLSurface"); - switch (GetGLImplementation()) { - case kGLImplementationDesktopGL: - case kGLImplementationAppleGL: { - scoped_refptr surface(new NoOpGLSurface(size, conf)); - if (!surface->Initialize()) - return NULL; + if (!surface->Initialize()) + return NULL; - return surface; - } - case kGLImplementationMockGL: - return new GLSurfaceStub(conf); - default: - NOTREACHED(); - return NULL; - } + return surface; } } // namespace gfx diff --git a/ui/gl/gl_surface_mac.h b/ui/gl/gl_surface_mac.h new file mode 100644 index 00000000000..6257f909502 --- /dev/null +++ b/ui/gl/gl_surface_mac.h @@ -0,0 +1,29 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "ui/gl/gl_surface.h" + +namespace gfx { + +class GL_EXPORT GLSurfaceMac : public GLSurface { + public: + GLSurfaceMac(gfx::AcceleratedWidget widget, + const gfx::SurfaceConfiguration requested_configuration); + + bool SwapBuffers() override; + void Destroy() override; + bool IsOffscreen() override; + gfx::Size GetSize() override; + void* GetHandle() override; + bool OnMakeCurrent(GLContext* context) override; + + private: + ~GLSurfaceMac() override; + + gfx::AcceleratedWidget widget_; + + DISALLOW_COPY_AND_ASSIGN(GLSurfaceMac); +}; + +} // namespace gfx From a421da3c1b20a7625a29f06a8a86ee9b55a8d25e Mon Sep 17 00:00:00 2001 From: Matt Perry Date: Tue, 21 Jul 2015 12:55:16 -0700 Subject: [PATCH 02/11] Renamed AnimatedType to AnimatedValue --- sky/sdk/BUILD.gn | 1 + sky/sdk/example/stocks/lib/stock_home.dart | 6 +- sky/sdk/example/widgets/card_collection.dart | 3 +- sky/sdk/lib/animation/animated_value.dart | 79 +++++++++++++++++++ .../lib/animation/animation_performance.dart | 69 +--------------- sky/sdk/lib/rendering/flex.dart | 3 +- sky/sdk/lib/widgets/animated_container.dart | 21 ++--- sky/sdk/lib/widgets/animation_builder.dart | 24 ++---- sky/sdk/lib/widgets/dismissable.dart | 11 +-- sky/sdk/lib/widgets/drawer.dart | 8 +- sky/sdk/lib/widgets/ink_well.dart | 5 +- sky/sdk/lib/widgets/navigator.dart | 9 ++- sky/sdk/lib/widgets/popup_menu.dart | 21 ++--- sky/sdk/lib/widgets/toggleable.dart | 7 +- 14 files changed, 140 insertions(+), 127 deletions(-) create mode 100644 sky/sdk/lib/animation/animated_value.dart diff --git a/sky/sdk/BUILD.gn b/sky/sdk/BUILD.gn index 9e896d6d478..8ee6c835fdc 100644 --- a/sky/sdk/BUILD.gn +++ b/sky/sdk/BUILD.gn @@ -9,6 +9,7 @@ dart_pkg("sky") { "CHANGELOG.md", "bin/init.dart", "lib/animation/animated_simulation.dart", + "lib/animation/animated_value.dart", "lib/animation/animation_performance.dart", "lib/animation/curves.dart", "lib/animation/forces.dart", diff --git a/sky/sdk/example/stocks/lib/stock_home.dart b/sky/sdk/example/stocks/lib/stock_home.dart index b7a314c160a..b7a8b890262 100644 --- a/sky/sdk/example/stocks/lib/stock_home.dart +++ b/sky/sdk/example/stocks/lib/stock_home.dart @@ -3,7 +3,7 @@ // found in the LICENSE file. import 'package:sky/editing/input.dart'; -import 'package:sky/animation/animation_performance.dart'; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/widgets/animated_component.dart'; import 'package:sky/widgets/animation_builder.dart'; import 'package:sky/theme/colors.dart' as colors; @@ -280,10 +280,10 @@ class StockHome extends AnimatedComponent { void _handleStockPurchased() { setState(() { _snackbarTransform = new AnimationBuilder() - ..position = new AnimatedType(const Point(0.0, 45.0), end: Point.origin); + ..position = new AnimatedValue(const Point(0.0, 45.0), end: Point.origin); var performance = _snackbarTransform.createPerformance( [_snackbarTransform.position], duration: _kSnackbarSlideDuration); - watch(performance); + watch(performance); // TODO(mpcomplete): need to unwatch performance.play(); }); } diff --git a/sky/sdk/example/widgets/card_collection.dart b/sky/sdk/example/widgets/card_collection.dart index 6725e372e1a..48c7b7a13ed 100644 --- a/sky/sdk/example/widgets/card_collection.dart +++ b/sky/sdk/example/widgets/card_collection.dart @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/animation/curves.dart'; import 'package:sky/base/lerp.dart'; @@ -100,7 +101,7 @@ class CardCollectionApp extends App { assert(card.performance == null); card.performance = new AnimationPerformance() ..duration = const Duration(milliseconds: 300) - ..variable = new AnimatedType( + ..variable = new AnimatedValue( card.height + kCardMargins.top + kCardMargins.bottom, end: 0.0, curve: ease, diff --git a/sky/sdk/lib/animation/animated_value.dart b/sky/sdk/lib/animation/animated_value.dart new file mode 100644 index 00000000000..92510295c33 --- /dev/null +++ b/sky/sdk/lib/animation/animated_value.dart @@ -0,0 +1,79 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import "dart:sky"; + +import 'package:sky/animation/curves.dart'; +import 'package:sky/base/lerp.dart'; + +abstract class AnimatedVariable { + void setProgress(double t); + String toString(); +} + +class Interval { + final double start; + final double end; + + double adjustTime(double t) { + return ((t - start) / (end - start)).clamp(0.0, 1.0); + } + + Interval(this.start, this.end) { + assert(start >= 0.0); + assert(start <= 1.0); + assert(end >= 0.0); + assert(end <= 1.0); + } +} + +class AnimatedValue extends AnimatedVariable { + AnimatedValue(this.begin, { this.end, this.interval, this.curve: linear }) { + value = begin; + } + + T value; + T begin; + T end; + Interval interval; + Curve curve; + + void setProgress(double t) { + if (end != null) { + double adjustedTime = interval == null ? t : interval.adjustTime(t); + if (adjustedTime == 1.0) { + value = end; + } else { + // TODO(mpcomplete): Reverse the timeline and curve. + value = begin + (end - begin) * curve.transform(adjustedTime); + } + } + } + + String toString() => 'AnimatedValue(begin=$begin, end=$end, value=$value)'; +} + +class AnimatedList extends AnimatedVariable { + List variables; + Interval interval; + + AnimatedList(this.variables, { this.interval }); + + void setProgress(double t) { + double adjustedTime = interval == null ? t : interval.adjustTime(t); + for (AnimatedVariable variable in variables) + variable.setProgress(adjustedTime); + } + + String toString() => 'AnimatedList([$variables])'; +} + +class AnimatedColor extends AnimatedValue { + AnimatedColor(Color begin, { Color end, Curve curve: linear }) + : super(begin, end: end, curve: curve); + + void setProgress(double t) { + value = lerpColor(begin, end, t); + } +} diff --git a/sky/sdk/lib/animation/animation_performance.dart b/sky/sdk/lib/animation/animation_performance.dart index 5c678c1418d..716165ae6ec 100644 --- a/sky/sdk/lib/animation/animation_performance.dart +++ b/sky/sdk/lib/animation/animation_performance.dart @@ -4,71 +4,9 @@ import 'dart:async'; -import 'package:sky/animation/timeline.dart'; -import 'package:sky/animation/curves.dart'; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/forces.dart'; - -abstract class AnimatedVariable { - void setFraction(double t); - String toString(); -} - -class Interval { - final double start; - final double end; - - double adjustTime(double t) { - return ((t - start) / (end - start)).clamp(0.0, 1.0); - } - - Interval(this.start, this.end) { - assert(start >= 0.0); - assert(start <= 1.0); - assert(end >= 0.0); - assert(end <= 1.0); - } -} - -class AnimatedType extends AnimatedVariable { - AnimatedType(this.begin, { this.end, this.interval, this.curve: linear }) { - value = begin; - } - - T value; - T begin; - T end; - Interval interval; - Curve curve; - - void setFraction(double t) { - if (end != null) { - double adjustedTime = interval == null ? t : interval.adjustTime(t); - if (adjustedTime == 1.0) { - value = end; - } else { - // TODO(mpcomplete): Reverse the timeline and curve. - value = begin + (end - begin) * curve.transform(adjustedTime); - } - } - } - - String toString() => 'AnimatedType(begin=$begin, end=$end, value=$value)'; -} - -class AnimatedList extends AnimatedVariable { - List variables; - Interval interval; - - AnimatedList(this.variables, { this.interval }); - - void setFraction(double t) { - double adjustedTime = interval == null ? t : interval.adjustTime(t); - for (AnimatedVariable variable in variables) - variable.setFraction(adjustedTime); - } - - String toString() => 'AnimatedList([$variables])'; -} +import 'package:sky/animation/timeline.dart'; // This class manages a "performance" - a collection of values that change // based on a timeline. For example, a performance may handle an animation @@ -82,7 +20,6 @@ class AnimationPerformance { _timeline = new Timeline(_tick); } - // TODO(mpcomplete): make this a list, or composable somehow. AnimatedVariable variable; // TODO(mpcomplete): duration should be on a director. Duration duration; @@ -142,7 +79,7 @@ class AnimationPerformance { } void _tick(double t) { - variable.setFraction(t); + variable.setProgress(t); _notifyListeners(); } } diff --git a/sky/sdk/lib/rendering/flex.dart b/sky/sdk/lib/rendering/flex.dart index a25aa292ac2..d36afe074a5 100644 --- a/sky/sdk/lib/rendering/flex.dart +++ b/sky/sdk/lib/rendering/flex.dart @@ -83,6 +83,7 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin _textBaseline; void set textBaseline (TextBaseline value) { @@ -92,8 +93,6 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin { +class AnimatedBoxConstraintsValue extends AnimatedValue { AnimatedBoxConstraintsValue(BoxConstraints begin, { BoxConstraints end, Curve curve: linear }) : super(begin, end: end, curve: curve); - void setFraction(double t) { + void setProgress(double t) { // TODO(abarth): We should lerp the BoxConstraints. value = end; } } -class AnimatedBoxDecorationValue extends AnimatedType { +class AnimatedBoxDecorationValue extends AnimatedValue { AnimatedBoxDecorationValue(BoxDecoration begin, { BoxDecoration end, Curve curve: linear }) : super(begin, end: end, curve: curve); - void setFraction(double t) { + void setProgress(double t) { if (t == 1.0) { value = end; return; @@ -34,11 +35,11 @@ class AnimatedBoxDecorationValue extends AnimatedType { } } -class AnimatedEdgeDimsValue extends AnimatedType { +class AnimatedEdgeDimsValue extends AnimatedValue { AnimatedEdgeDimsValue(EdgeDims begin, { EdgeDims end, Curve curve: linear }) : super(begin, end: end, curve: curve); - void setFraction(double t) { + void setProgress(double t) { if (t == 1.0) { value = end; return; @@ -54,7 +55,7 @@ class AnimatedEdgeDimsValue extends AnimatedType { class ImplicitlyAnimatedValue { final AnimationPerformance performance = new AnimationPerformance(); - final AnimatedType _variable; + final AnimatedValue _variable; ImplicitlyAnimatedValue(this._variable, Duration duration) { performance @@ -168,21 +169,21 @@ class AnimatedContainer extends AnimatedComponent { void _updateTransform() { _updateField(transform, _transform, () { - _transform = new ImplicitlyAnimatedValue(new AnimatedType(transform), duration); + _transform = new ImplicitlyAnimatedValue(new AnimatedValue(transform), duration); watch(_transform.performance); }); } void _updateWidth() { _updateField(width, _width, () { - _width = new ImplicitlyAnimatedValue(new AnimatedType(width), duration); + _width = new ImplicitlyAnimatedValue(new AnimatedValue(width), duration); watch(_width.performance); }); } void _updateHeight() { _updateField(height, _height, () { - _height = new ImplicitlyAnimatedValue( new AnimatedType(height), duration); + _height = new ImplicitlyAnimatedValue( new AnimatedValue(height), duration); watch(_height.performance); }); } diff --git a/sky/sdk/lib/widgets/animation_builder.dart b/sky/sdk/lib/widgets/animation_builder.dart index 15cff58ad11..a0362f3684d 100644 --- a/sky/sdk/lib/widgets/animation_builder.dart +++ b/sky/sdk/lib/widgets/animation_builder.dart @@ -4,9 +4,8 @@ import 'package:vector_math/vector_math.dart'; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; -import 'package:sky/animation/curves.dart'; -import 'package:sky/base/lerp.dart'; import 'package:sky/painting/box_painter.dart'; import 'package:sky/theme/shadows.dart'; import 'package:sky/widgets/basic.dart'; @@ -18,9 +17,9 @@ class AnimationBuilder { AnimationBuilder(); - AnimatedType opacity; - AnimatedType position; - AnimatedType shadow; + AnimatedValue opacity; + AnimatedValue position; + AnimatedValue shadow; AnimatedColor backgroundColor; // These don't animate, but are used to build the AnimationBuilder anyway. @@ -30,7 +29,7 @@ class AnimationBuilder { Map _variableToPerformance = new Map(); - AnimationPerformance createPerformance(List variables, + AnimationPerformance createPerformance(List variables, { Duration duration }) { AnimationPerformance performance = new AnimationPerformance() ..duration = duration @@ -67,7 +66,7 @@ class AnimationBuilder { } void updateFields({ - AnimatedType shadow, + AnimatedValue shadow, AnimatedColor backgroundColor, double borderRadius, Shape shape @@ -78,7 +77,7 @@ class AnimationBuilder { this.shape = shape; } - void _updateField(AnimatedType variable, AnimatedType sourceVariable) { + void _updateField(AnimatedValue variable, AnimatedValue sourceVariable) { if (variable == null) return; // TODO(mpcomplete): Should we handle transition from null? @@ -101,15 +100,6 @@ class AnimationBuilder { } } -class AnimatedColor extends AnimatedType { - AnimatedColor(Color begin, { Color end, Curve curve: linear }) - : super(begin, end: end, curve: curve); - - void setFraction(double t) { - value = lerpColor(begin, end, t); - } -} - List _computeShadow(double level) { if (level < 1.0) // shadows[1] is the first shadow return null; diff --git a/sky/sdk/lib/widgets/dismissable.dart b/sky/sdk/lib/widgets/dismissable.dart index 614f1f04c49..9362dfc7ea0 100644 --- a/sky/sdk/lib/widgets/dismissable.dart +++ b/sky/sdk/lib/widgets/dismissable.dart @@ -4,6 +4,7 @@ import 'dart:sky' as sky; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/widgets/animated_component.dart'; import 'package:sky/widgets/basic.dart'; @@ -13,7 +14,7 @@ import 'package:vector_math/vector_math.dart'; const Duration _kCardDismissFadeout = const Duration(milliseconds: 200); const double _kMinFlingVelocity = 700.0; const double _kMinFlingVelocityDelta = 400.0; -const double _kFlingVelocityScale = 1.0/300.0; +const double _kFlingVelocityScale = 1.0 / 300.0; const double _kDismissCardThreshold = 0.6; typedef void DismissedCallback(); @@ -30,8 +31,8 @@ class Dismissable extends AnimatedComponent { Widget child; DismissedCallback onDismissed; - AnimatedType _position; - AnimatedType _opacity; + AnimatedValue _position; + AnimatedValue _opacity; AnimationPerformance _performance; double _width; @@ -39,8 +40,8 @@ class Dismissable extends AnimatedComponent { bool _dragUnderway = false; void initState() { - _position = new AnimatedType(Point.origin); - _opacity = new AnimatedType(1.0, end: 0.0); + _position = new AnimatedValue(Point.origin); + _opacity = new AnimatedValue(1.0, end: 0.0); _performance = new AnimationPerformance() ..duration = _kCardDismissFadeout ..variable = new AnimatedList([_position, _opacity]) diff --git a/sky/sdk/lib/widgets/drawer.dart b/sky/sdk/lib/widgets/drawer.dart index 60f3682e826..781970ea1d7 100644 --- a/sky/sdk/lib/widgets/drawer.dart +++ b/sky/sdk/lib/widgets/drawer.dart @@ -4,11 +4,11 @@ import 'dart:sky' as sky; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/theme/shadows.dart'; import 'package:sky/theme/colors.dart' as colors; import 'package:sky/widgets/animated_component.dart'; -import 'package:sky/widgets/animation_builder.dart'; import 'package:sky/widgets/basic.dart'; import 'package:sky/widgets/navigator.dart'; import 'package:sky/widgets/scrollable_viewport.dart'; @@ -30,7 +30,7 @@ import 'package:vector_math/vector_math.dart'; const double _kWidth = 304.0; const double _kMinFlingVelocity = 365.0; -const double _kFlingVelocityScale = 1.0/300.0; +const double _kFlingVelocityScale = 1.0 / 300.0; const Duration _kBaseSettleDuration = const Duration(milliseconds: 246); const Point _kOpenPosition = Point.origin; const Point _kClosedPosition = const Point(-_kWidth, 0.0); @@ -60,12 +60,12 @@ class Drawer extends AnimatedComponent { DrawerStatusChangedCallback onStatusChanged; Navigator navigator; - AnimatedType _position; + AnimatedValue _position; AnimatedColor _maskColor; AnimationPerformance _performance; void initState() { - _position = new AnimatedType(_kClosedPosition, end: _kOpenPosition); + _position = new AnimatedValue(_kClosedPosition, end: _kOpenPosition); _maskColor = new AnimatedColor(colors.transparent, end: const Color(0x7F000000)); _performance = new AnimationPerformance() ..duration = _kBaseSettleDuration diff --git a/sky/sdk/lib/widgets/ink_well.dart b/sky/sdk/lib/widgets/ink_well.dart index f711fe18be3..158c6e469d2 100644 --- a/sky/sdk/lib/widgets/ink_well.dart +++ b/sky/sdk/lib/widgets/ink_well.dart @@ -5,6 +5,7 @@ import 'dart:math' as math; import 'dart:sky' as sky; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/animation/curves.dart'; import 'package:sky/rendering/box.dart'; @@ -29,7 +30,7 @@ double _getSplashTargetSize(Size bounds, Point position) { class InkSplash { InkSplash(this.pointer, this.position, this.well) { _targetRadius = _getSplashTargetSize(well.size, position); - _radius = new AnimatedType( + _radius = new AnimatedValue( _kSplashInitialSize, end: _targetRadius, curve: easeOut); _performance = new AnimationPerformance() @@ -45,7 +46,7 @@ class InkSplash { double _targetRadius; double _pinnedRadius; - AnimatedType _radius; + AnimatedValue _radius; AnimationPerformance _performance; void _updateVelocity(double velocity) { diff --git a/sky/sdk/lib/widgets/navigator.dart b/sky/sdk/lib/widgets/navigator.dart index 42df2d2d560..8254bbef58d 100644 --- a/sky/sdk/lib/widgets/navigator.dart +++ b/sky/sdk/lib/widgets/navigator.dart @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/animation/curves.dart'; import 'package:sky/widgets/animated_component.dart'; @@ -59,17 +60,17 @@ class Transition extends AnimatedComponent { Function onDismissed; Function onCompleted; - AnimatedType _position; - AnimatedType _opacity; + AnimatedValue _position; + AnimatedValue _opacity; AnimationPerformance _performance; void initState() { - _position = new AnimatedType( + _position = new AnimatedValue( _kTransitionStartPoint, end: Point.origin, curve: easeOut ); - _opacity = new AnimatedType(0.0, end: 1.0) + _opacity = new AnimatedValue(0.0, end: 1.0) ..curve = easeOut; _performance = new AnimationPerformance() ..duration = _kTransitionDuration diff --git a/sky/sdk/lib/widgets/popup_menu.dart b/sky/sdk/lib/widgets/popup_menu.dart index 2d8a0dd50e7..85e9bd70c64 100644 --- a/sky/sdk/lib/widgets/popup_menu.dart +++ b/sky/sdk/lib/widgets/popup_menu.dart @@ -5,6 +5,7 @@ import 'dart:math' as math; import 'dart:sky' as sky; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/painting/box_painter.dart'; import 'package:sky/theme/colors.dart'; @@ -48,10 +49,10 @@ class PopupMenu extends AnimatedComponent { int level; Navigator navigator; - AnimatedType _opacity; - AnimatedType _width; - AnimatedType _height; - List> _itemOpacities; + AnimatedValue _opacity; + AnimatedValue _width; + AnimatedValue _height; + List> _itemOpacities; AnimatedList _animationList; AnimationPerformance _performance; @@ -88,14 +89,14 @@ class PopupMenu extends AnimatedComponent { void _updateAnimationVariables() { double unit = 1.0 / (items.length + 1.5); // 1.0 for the width and 0.5 for the last item's fade. - _opacity = new AnimatedType(0.0, end: 1.0); - _width = new AnimatedType(0.0, end: 1.0, interval: new Interval(0.0, unit)); - _height = new AnimatedType(0.0, end: 1.0, interval: new Interval(0.0, unit * items.length)); - _itemOpacities = new List>(); + _opacity = new AnimatedValue(0.0, end: 1.0); + _width = new AnimatedValue(0.0, end: 1.0, interval: new Interval(0.0, unit)); + _height = new AnimatedValue(0.0, end: 1.0, interval: new Interval(0.0, unit * items.length)); + _itemOpacities = new List>(); for (int i = 0; i < items.length; ++i) { double start = (i + 1) * unit; double end = (start + 1.5 * unit).clamp(0.0, 1.0); - _itemOpacities.add(new AnimatedType( + _itemOpacities.add(new AnimatedValue( 0.0, end: 1.0, interval: new Interval(start, end))); } List variables = new List() @@ -121,7 +122,7 @@ class PopupMenu extends AnimatedComponent { PopupMenuStatus status = _status; if (_lastStatus != null && status != _lastStatus) { if (status == PopupMenuStatus.inactive && - navigator != null && + navigator != null && navigator.currentRoute.key == this) navigator.pop(); if (onStatusChanged != null) diff --git a/sky/sdk/lib/widgets/toggleable.dart b/sky/sdk/lib/widgets/toggleable.dart index 6ef04d0cab6..8fd8b1c44fe 100644 --- a/sky/sdk/lib/widgets/toggleable.dart +++ b/sky/sdk/lib/widgets/toggleable.dart @@ -4,6 +4,7 @@ import 'dart:sky' as sky; +import 'package:sky/animation/animated_value.dart'; import 'package:sky/animation/animation_performance.dart'; import 'package:sky/animation/curves.dart'; import 'package:sky/widgets/animated_component.dart'; @@ -24,14 +25,14 @@ abstract class Toggleable extends AnimatedComponent { bool value; ValueChanged onChanged; - AnimatedType _position; - AnimatedType get position => _position; + AnimatedValue _position; + AnimatedValue get position => _position; AnimationPerformance _performance; AnimationPerformance get performance => _performance; void initState() { - _position = new AnimatedType(0.0, end: 1.0); + _position = new AnimatedValue(0.0, end: 1.0); _performance = new AnimationPerformance() ..variable = position ..duration = _kCheckDuration From 2c1db4b8e4da639c6a0ee5fd0fa259887b1d1ac7 Mon Sep 17 00:00:00 2001 From: Chinmay Garde Date: Tue, 21 Jul 2015 13:42:23 -0700 Subject: [PATCH 03/11] Add GL bindings for extensions "GL_KHR_blend_equation" and "GL_KHR_debug" --- ui/gl/generate_bindings.py | 34 + ui/gl/gl_bindings.h | 4 + ui/gl/gl_bindings_api_autogen_gl.h | 31 + ui/gl/gl_bindings_autogen_egl.cc | 48 +- ui/gl/gl_bindings_autogen_gl.cc | 827 ++++-- ui/gl/gl_bindings_autogen_gl.h | 83 + ui/gl/gl_bindings_autogen_glx.cc | 105 +- ui/gl/gl_bindings_autogen_mock.cc | 295 +- ui/gl/gl_bindings_autogen_mock.h | 580 ++-- ui/gl/gl_bindings_skia_in_process.cc | 51 + ui/gl/gl_enums_implementation_autogen.h | 3321 ++++++++--------------- ui/gl/gl_mock_autogen_gl.h | 32 + 12 files changed, 2601 insertions(+), 2810 deletions(-) diff --git a/ui/gl/generate_bindings.py b/ui/gl/generate_bindings.py index 6ebf3df5530..ffd96253d96 100755 --- a/ui/gl/generate_bindings.py +++ b/ui/gl/generate_bindings.py @@ -243,6 +243,20 @@ GL_FUNCTIONS = [ { 'return_type': 'void', 'names': ['glCullFace'], 'arguments': 'GLenum mode', }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glDebugMessageCallbackKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLDEBUGPROCKHR callback, const void* userparam' }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glDebugMessageControlKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLenum source, GLenum type, GLenum severity, GLsizei count, ' + 'const GLuint* ids, GLboolean enabled' }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glDebugMessageInsertKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLenum source, GLenum type, GLuint id, GLenum severity, ' + 'GLsizei length, const GLchar* buf' }, { 'return_type': 'void', 'names': ['glDeleteBuffers'], 'known_as': 'glDeleteBuffersARB', @@ -498,6 +512,12 @@ GL_FUNCTIONS = [ { 'return_type': 'void', 'names': ['glGetBufferParameteriv'], 'arguments': 'GLenum target, GLenum pname, GLint* params', }, +{ 'return_type': 'GLuint', + 'versions': [{ 'name': 'glGetDebugMessageLogKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, ' + 'GLuint* ids, GLenum* severities, GLsizei* lengths, ' + 'GLchar* messageLog' }, { 'return_type': 'GLenum', 'names': ['glGetError'], 'arguments': 'void', @@ -763,6 +783,11 @@ GL_FUNCTIONS = [ 'extensions': ['GL_EXT_direct_state_access', 'GL_NV_path_rendering'] },], 'arguments': 'GLenum matrixMode' }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glObjectLabelKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLenum identifier, GLuint name, GLsizei length, ' + 'const GLchar* label' }, { 'return_type': 'void', 'versions': [{ 'name': 'glPauseTransformFeedback' }], 'arguments': 'void', }, @@ -775,6 +800,10 @@ GL_FUNCTIONS = [ { 'return_type': 'void', 'names': ['glPolygonOffset'], 'arguments': 'GLfloat factor, GLfloat units', }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glPopDebugGroupKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'void' }, { 'return_type': 'void', 'names': ['glPopGroupMarkerEXT'], 'arguments': 'void', }, @@ -789,6 +818,11 @@ GL_FUNCTIONS = [ 'versions': [{ 'name': 'glProgramParameteri', 'extensions': ['GL_ARB_get_program_binary'] }], 'arguments': 'GLuint program, GLenum pname, GLint value' }, +{ 'return_type': 'void', + 'versions': [{ 'name': 'glPushDebugGroupKHR', + 'extensions': ['GL_KHR_debug'] }], + 'arguments': 'GLenum source, GLuint id, GLsizei length, ' + 'const GLchar* message' }, { 'return_type': 'void', 'names': ['glPushGroupMarkerEXT'], 'arguments': 'GLsizei length, const char* marker', }, diff --git a/ui/gl/gl_bindings.h b/ui/gl/gl_bindings.h index 48aff09679c..d3b15280ded 100644 --- a/ui/gl/gl_bindings.h +++ b/ui/gl/gl_bindings.h @@ -300,6 +300,10 @@ typedef void (*OSMESAproc)(); // Forward declare EGL types. typedef uint64 EGLuint64CHROMIUM; +typedef void (*GLDEBUGPROCKHR)(GLenum source, GLenum type, GLuint id, + GLenum severity, GLsizei length, + const GLchar *message, void *userParam); + #include "gl_bindings_autogen_gl.h" #include "gl_bindings_autogen_osmesa.h" diff --git a/ui/gl/gl_bindings_api_autogen_gl.h b/ui/gl/gl_bindings_api_autogen_gl.h index c6bc7f610ad..93253008035 100644 --- a/ui/gl/gl_bindings_api_autogen_gl.h +++ b/ui/gl/gl_bindings_api_autogen_gl.h @@ -174,6 +174,20 @@ void glCopyTexSubImage3DFn(GLenum target, GLuint glCreateProgramFn(void) override; GLuint glCreateShaderFn(GLenum type) override; void glCullFaceFn(GLenum mode) override; +void glDebugMessageCallbackKHRFn(GLDEBUGPROCKHR callback, + const void* userparam) override; +void glDebugMessageControlKHRFn(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) override; +void glDebugMessageInsertKHRFn(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) override; void glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) override; void glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) override; void glDeleteFencesNVFn(GLsizei n, const GLuint* fences) override; @@ -311,6 +325,14 @@ void glGetBooleanvFn(GLenum pname, GLboolean* params) override; void glGetBufferParameterivFn(GLenum target, GLenum pname, GLint* params) override; +GLuint glGetDebugMessageLogKHRFn(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) override; GLenum glGetErrorFn(void) override; void glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) override; void glGetFloatvFn(GLenum pname, GLfloat* params) override; @@ -452,16 +474,25 @@ void* glMapBufferRangeFn(GLenum target, GLbitfield access) override; void glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) override; void glMatrixLoadIdentityEXTFn(GLenum matrixMode) override; +void glObjectLabelKHRFn(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) override; void glPauseTransformFeedbackFn(void) override; void glPixelStoreiFn(GLenum pname, GLint param) override; void glPointParameteriFn(GLenum pname, GLint param) override; void glPolygonOffsetFn(GLfloat factor, GLfloat units) override; +void glPopDebugGroupKHRFn(void) override; void glPopGroupMarkerEXTFn(void) override; void glProgramBinaryFn(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override; void glProgramParameteriFn(GLuint program, GLenum pname, GLint value) override; +void glPushDebugGroupKHRFn(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) override; void glPushGroupMarkerEXTFn(GLsizei length, const char* marker) override; void glQueryCounterFn(GLuint id, GLenum target) override; void glReadBufferFn(GLenum src) override; diff --git a/ui/gl/gl_bindings_autogen_egl.cc b/ui/gl/gl_bindings_autogen_egl.cc index 003b5457823..26f7a71c844 100644 --- a/ui/gl/gl_bindings_autogen_egl.cc +++ b/ui/gl/gl_bindings_autogen_egl.cc @@ -229,8 +229,9 @@ static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) { return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { +static EGLBoolean GL_BINDING_CALL Debug_eglBindTexImage(EGLDisplay dpy, + EGLSurface surface, + EGLint buffer) { GL_SERVICE_LOG("eglBindTexImage" << "(" << dpy << ", " << surface << ", " << buffer << ")"); EGLBoolean result = @@ -381,8 +382,8 @@ Debug_eglCreateWindowSurface(EGLDisplay dpy, return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { +static EGLBoolean GL_BINDING_CALL Debug_eglDestroyContext(EGLDisplay dpy, + EGLContext ctx) { GL_SERVICE_LOG("eglDestroyContext" << "(" << dpy << ", " << ctx << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglDestroyContextFn(dpy, ctx); @@ -390,8 +391,8 @@ Debug_eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) { +static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy, + EGLImageKHR image) { GL_SERVICE_LOG("eglDestroyImageKHR" << "(" << dpy << ", " << image << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image); @@ -399,8 +400,8 @@ Debug_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) { return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { +static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy, + EGLSurface surface) { GL_SERVICE_LOG("eglDestroySurface" << "(" << dpy << ", " << surface << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface); @@ -408,8 +409,8 @@ Debug_eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) { +static EGLBoolean GL_BINDING_CALL Debug_eglDestroySyncKHR(EGLDisplay dpy, + EGLSyncKHR sync) { GL_SERVICE_LOG("eglDestroySyncKHR" << "(" << dpy << ", " << sync << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglDestroySyncKHRFn(dpy, sync); @@ -542,8 +543,9 @@ Debug_eglGetSyncValuesCHROMIUM(EGLDisplay dpy, return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) { +static EGLBoolean GL_BINDING_CALL Debug_eglInitialize(EGLDisplay dpy, + EGLint* major, + EGLint* minor) { GL_SERVICE_LOG("eglInitialize" << "(" << dpy << ", " << static_cast(major) << ", " << static_cast(minor) << ")"); @@ -602,8 +604,8 @@ static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy, return result; } -static const char* GL_BINDING_CALL -Debug_eglQueryString(EGLDisplay dpy, EGLint name) { +static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy, + EGLint name) { GL_SERVICE_LOG("eglQueryString" << "(" << dpy << ", " << name << ")"); const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name); @@ -638,8 +640,9 @@ Debug_eglQuerySurfacePointerANGLE(EGLDisplay dpy, return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { +static EGLBoolean GL_BINDING_CALL Debug_eglReleaseTexImage(EGLDisplay dpy, + EGLSurface surface, + EGLint buffer) { GL_SERVICE_LOG("eglReleaseTexImage" << "(" << dpy << ", " << surface << ", " << buffer << ")"); EGLBoolean result = @@ -670,8 +673,8 @@ static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy, return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { +static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy, + EGLSurface surface) { GL_SERVICE_LOG("eglSwapBuffers" << "(" << dpy << ", " << surface << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface); @@ -679,8 +682,8 @@ Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { return result; } -static EGLBoolean GL_BINDING_CALL -Debug_eglSwapInterval(EGLDisplay dpy, EGLint interval) { +static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy, + EGLint interval) { GL_SERVICE_LOG("eglSwapInterval" << "(" << dpy << ", " << interval << ")"); EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval); @@ -722,8 +725,9 @@ static EGLBoolean GL_BINDING_CALL Debug_eglWaitNative(EGLint engine) { return result; } -static EGLint GL_BINDING_CALL -Debug_eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) { +static EGLint GL_BINDING_CALL Debug_eglWaitSyncKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLint flags) { GL_SERVICE_LOG("eglWaitSyncKHR" << "(" << dpy << ", " << sync << ", " << flags << ")"); EGLint result = g_driver_egl.debug_fn.eglWaitSyncKHRFn(dpy, sync, flags); diff --git a/ui/gl/gl_bindings_autogen_gl.cc b/ui/gl/gl_bindings_autogen_gl.cc index def04371f5d..f9c6ebf13b2 100644 --- a/ui/gl/gl_bindings_autogen_gl.cc +++ b/ui/gl/gl_bindings_autogen_gl.cc @@ -99,6 +99,9 @@ void DriverGL::InitializeStaticBindings() { reinterpret_cast(GetGLProcAddress("glCreateShader")); fn.glCullFaceFn = reinterpret_cast(GetGLProcAddress("glCullFace")); + fn.glDebugMessageCallbackKHRFn = 0; + fn.glDebugMessageControlKHRFn = 0; + fn.glDebugMessageInsertKHRFn = 0; fn.glDeleteBuffersARBFn = reinterpret_cast( GetGLProcAddress("glDeleteBuffers")); fn.glDeleteFencesAPPLEFn = 0; @@ -189,6 +192,7 @@ void DriverGL::InitializeStaticBindings() { reinterpret_cast(GetGLProcAddress("glGetBooleanv")); fn.glGetBufferParameterivFn = reinterpret_cast( GetGLProcAddress("glGetBufferParameteriv")); + fn.glGetDebugMessageLogKHRFn = 0; fn.glGetErrorFn = reinterpret_cast(GetGLProcAddress("glGetError")); fn.glGetFenceivNVFn = 0; @@ -282,15 +286,18 @@ void DriverGL::InitializeStaticBindings() { fn.glMapBufferRangeFn = 0; fn.glMatrixLoadfEXTFn = 0; fn.glMatrixLoadIdentityEXTFn = 0; + fn.glObjectLabelKHRFn = 0; fn.glPauseTransformFeedbackFn = 0; fn.glPixelStoreiFn = reinterpret_cast(GetGLProcAddress("glPixelStorei")); fn.glPointParameteriFn = 0; fn.glPolygonOffsetFn = reinterpret_cast( GetGLProcAddress("glPolygonOffset")); + fn.glPopDebugGroupKHRFn = 0; fn.glPopGroupMarkerEXTFn = 0; fn.glProgramBinaryFn = 0; fn.glProgramParameteriFn = 0; + fn.glPushDebugGroupKHRFn = 0; fn.glPushGroupMarkerEXTFn = 0; fn.glQueryCounterFn = 0; fn.glReadBufferFn = 0; @@ -515,6 +522,7 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { std::string::npos; ext.b_GL_KHR_blend_equation_advanced = extensions.find("GL_KHR_blend_equation_advanced ") != std::string::npos; + ext.b_GL_KHR_debug = extensions.find("GL_KHR_debug ") != std::string::npos; ext.b_GL_KHR_robustness = extensions.find("GL_KHR_robustness ") != std::string::npos; ext.b_GL_NV_blend_equation_advanced = @@ -754,6 +762,30 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { DCHECK(fn.glCopyTexSubImage3DFn); } + debug_fn.glDebugMessageCallbackKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glDebugMessageCallbackKHRFn = + reinterpret_cast( + GetGLProcAddress("glDebugMessageCallbackKHR")); + DCHECK(fn.glDebugMessageCallbackKHRFn); + } + + debug_fn.glDebugMessageControlKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glDebugMessageControlKHRFn = + reinterpret_cast( + GetGLProcAddress("glDebugMessageControlKHR")); + DCHECK(fn.glDebugMessageControlKHRFn); + } + + debug_fn.glDebugMessageInsertKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glDebugMessageInsertKHRFn = + reinterpret_cast( + GetGLProcAddress("glDebugMessageInsertKHR")); + DCHECK(fn.glDebugMessageInsertKHRFn); + } + debug_fn.glDeleteFencesAPPLEFn = 0; if (ext.b_GL_APPLE_fence) { fn.glDeleteFencesAPPLEFn = reinterpret_cast( @@ -1168,6 +1200,14 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { DCHECK(fn.glGetActiveUniformsivFn); } + debug_fn.glGetDebugMessageLogKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glGetDebugMessageLogKHRFn = + reinterpret_cast( + GetGLProcAddress("glGetDebugMessageLogKHR")); + DCHECK(fn.glGetDebugMessageLogKHRFn); + } + debug_fn.glGetFenceivNVFn = 0; if (ext.b_GL_NV_fence) { fn.glGetFenceivNVFn = reinterpret_cast( @@ -1584,6 +1624,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { DCHECK(fn.glMatrixLoadIdentityEXTFn); } + debug_fn.glObjectLabelKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glObjectLabelKHRFn = reinterpret_cast( + GetGLProcAddress("glObjectLabelKHR")); + DCHECK(fn.glObjectLabelKHRFn); + } + debug_fn.glPauseTransformFeedbackFn = 0; if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u)) { fn.glPauseTransformFeedbackFn = @@ -1599,6 +1646,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { DCHECK(fn.glPointParameteriFn); } + debug_fn.glPopDebugGroupKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glPopDebugGroupKHRFn = reinterpret_cast( + GetGLProcAddress("glPopDebugGroupKHR")); + DCHECK(fn.glPopDebugGroupKHRFn); + } + debug_fn.glPopGroupMarkerEXTFn = 0; if (ext.b_GL_EXT_debug_marker) { fn.glPopGroupMarkerEXTFn = reinterpret_cast( @@ -1626,6 +1680,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) { DCHECK(fn.glProgramParameteriFn); } + debug_fn.glPushDebugGroupKHRFn = 0; + if (ext.b_GL_KHR_debug) { + fn.glPushDebugGroupKHRFn = reinterpret_cast( + GetGLProcAddress("glPushDebugGroupKHR")); + DCHECK(fn.glPushDebugGroupKHRFn); + } + debug_fn.glPushGroupMarkerEXTFn = 0; if (ext.b_GL_EXT_debug_marker) { fn.glPushGroupMarkerEXTFn = reinterpret_cast( @@ -2015,8 +2076,8 @@ static void GL_BINDING_CALL Debug_glActiveTexture(GLenum texture) { g_driver_gl.debug_fn.glActiveTextureFn(texture); } -static void GL_BINDING_CALL -Debug_glAttachShader(GLuint program, GLuint shader) { +static void GL_BINDING_CALL Debug_glAttachShader(GLuint program, + GLuint shader) { GL_SERVICE_LOG("glAttachShader" << "(" << program << ", " << shader << ")"); g_driver_gl.debug_fn.glAttachShaderFn(program, shader); @@ -2035,8 +2096,9 @@ Debug_glBeginTransformFeedback(GLenum primitiveMode) { g_driver_gl.debug_fn.glBeginTransformFeedbackFn(primitiveMode); } -static void GL_BINDING_CALL -Debug_glBindAttribLocation(GLuint program, GLuint index, const char* name) { +static void GL_BINDING_CALL Debug_glBindAttribLocation(GLuint program, + GLuint index, + const char* name) { GL_SERVICE_LOG("glBindAttribLocation" << "(" << program << ", " << index << ", " << name << ")"); g_driver_gl.debug_fn.glBindAttribLocationFn(program, index, name); @@ -2049,8 +2111,9 @@ static void GL_BINDING_CALL Debug_glBindBuffer(GLenum target, GLuint buffer) { g_driver_gl.debug_fn.glBindBufferFn(target, buffer); } -static void GL_BINDING_CALL -Debug_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) { +static void GL_BINDING_CALL Debug_glBindBufferBase(GLenum target, + GLuint index, + GLuint buffer) { GL_SERVICE_LOG("glBindBufferBase" << "(" << GLEnums::GetStringEnum(target) << ", " << index << ", " << buffer << ")"); @@ -2089,16 +2152,16 @@ Debug_glBindFragDataLocationIndexed(GLuint program, index, name); } -static void GL_BINDING_CALL -Debug_glBindFramebufferEXT(GLenum target, GLuint framebuffer) { +static void GL_BINDING_CALL Debug_glBindFramebufferEXT(GLenum target, + GLuint framebuffer) { GL_SERVICE_LOG("glBindFramebufferEXT" << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer << ")"); g_driver_gl.debug_fn.glBindFramebufferEXTFn(target, framebuffer); } -static void GL_BINDING_CALL -Debug_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) { +static void GL_BINDING_CALL Debug_glBindRenderbufferEXT(GLenum target, + GLuint renderbuffer) { GL_SERVICE_LOG("glBindRenderbufferEXT" << "(" << GLEnums::GetStringEnum(target) << ", " << renderbuffer << ")"); @@ -2118,8 +2181,8 @@ static void GL_BINDING_CALL Debug_glBindTexture(GLenum target, GLuint texture) { g_driver_gl.debug_fn.glBindTextureFn(target, texture); } -static void GL_BINDING_CALL -Debug_glBindTransformFeedback(GLenum target, GLuint id) { +static void GL_BINDING_CALL Debug_glBindTransformFeedback(GLenum target, + GLuint id) { GL_SERVICE_LOG("glBindTransformFeedback" << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")"); g_driver_gl.debug_fn.glBindTransformFeedbackFn(target, id); @@ -2154,8 +2217,8 @@ static void GL_BINDING_CALL Debug_glBlendEquation(GLenum mode) { g_driver_gl.debug_fn.glBlendEquationFn(mode); } -static void GL_BINDING_CALL -Debug_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { +static void GL_BINDING_CALL Debug_glBlendEquationSeparate(GLenum modeRGB, + GLenum modeAlpha) { GL_SERVICE_LOG("glBlendEquationSeparate" << "(" << GLEnums::GetStringEnum(modeRGB) << ", " << GLEnums::GetStringEnum(modeAlpha) << ")"); @@ -2287,24 +2350,27 @@ static void GL_BINDING_CALL Debug_glClearBufferfi(GLenum buffer, g_driver_gl.debug_fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil); } -static void GL_BINDING_CALL -Debug_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) { +static void GL_BINDING_CALL Debug_glClearBufferfv(GLenum buffer, + GLint drawbuffer, + const GLfloat* value) { GL_SERVICE_LOG("glClearBufferfv" << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer << ", " << static_cast(value) << ")"); g_driver_gl.debug_fn.glClearBufferfvFn(buffer, drawbuffer, value); } -static void GL_BINDING_CALL -Debug_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) { +static void GL_BINDING_CALL Debug_glClearBufferiv(GLenum buffer, + GLint drawbuffer, + const GLint* value) { GL_SERVICE_LOG("glClearBufferiv" << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer << ", " << static_cast(value) << ")"); g_driver_gl.debug_fn.glClearBufferivFn(buffer, drawbuffer, value); } -static void GL_BINDING_CALL -Debug_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) { +static void GL_BINDING_CALL Debug_glClearBufferuiv(GLenum buffer, + GLint drawbuffer, + const GLuint* value) { GL_SERVICE_LOG("glClearBufferuiv" << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer << ", " << static_cast(value) << ")"); @@ -2339,8 +2405,9 @@ static void GL_BINDING_CALL Debug_glClearStencil(GLint s) { g_driver_gl.debug_fn.glClearStencilFn(s); } -static GLenum GL_BINDING_CALL -Debug_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { +static GLenum GL_BINDING_CALL Debug_glClientWaitSync(GLsync sync, + GLbitfield flags, + GLuint64 timeout) { GL_SERVICE_LOG("glClientWaitSync" << "(" << sync << ", " << flags << ", " << timeout << ")"); GLenum result = g_driver_gl.debug_fn.glClientWaitSyncFn(sync, flags, timeout); @@ -2509,23 +2576,63 @@ static void GL_BINDING_CALL Debug_glCullFace(GLenum mode) { } static void GL_BINDING_CALL -Debug_glDeleteBuffersARB(GLsizei n, const GLuint* buffers) { +Debug_glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, + const void* userparam) { + GL_SERVICE_LOG("glDebugMessageCallbackKHR" + << "(" << callback << ", " + << static_cast(userparam) << ")"); + g_driver_gl.debug_fn.glDebugMessageCallbackKHRFn(callback, userparam); +} + +static void GL_BINDING_CALL Debug_glDebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) { + GL_SERVICE_LOG("glDebugMessageControlKHR" + << "(" << GLEnums::GetStringEnum(source) << ", " + << GLEnums::GetStringEnum(type) << ", " + << GLEnums::GetStringEnum(severity) << ", " << count << ", " + << static_cast(ids) << ", " + << GLEnums::GetStringBool(enabled) << ")"); + g_driver_gl.debug_fn.glDebugMessageControlKHRFn(source, type, severity, count, + ids, enabled); +} + +static void GL_BINDING_CALL Debug_glDebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) { + GL_SERVICE_LOG("glDebugMessageInsertKHR" + << "(" << GLEnums::GetStringEnum(source) << ", " + << GLEnums::GetStringEnum(type) << ", " << id << ", " + << GLEnums::GetStringEnum(severity) << ", " << length << ", " + << static_cast(buf) << ")"); + g_driver_gl.debug_fn.glDebugMessageInsertKHRFn(source, type, id, severity, + length, buf); +} + +static void GL_BINDING_CALL Debug_glDeleteBuffersARB(GLsizei n, + const GLuint* buffers) { GL_SERVICE_LOG("glDeleteBuffersARB" << "(" << n << ", " << static_cast(buffers) << ")"); g_driver_gl.debug_fn.glDeleteBuffersARBFn(n, buffers); } -static void GL_BINDING_CALL -Debug_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences) { +static void GL_BINDING_CALL Debug_glDeleteFencesAPPLE(GLsizei n, + const GLuint* fences) { GL_SERVICE_LOG("glDeleteFencesAPPLE" << "(" << n << ", " << static_cast(fences) << ")"); g_driver_gl.debug_fn.glDeleteFencesAPPLEFn(n, fences); } -static void GL_BINDING_CALL -Debug_glDeleteFencesNV(GLsizei n, const GLuint* fences) { +static void GL_BINDING_CALL Debug_glDeleteFencesNV(GLsizei n, + const GLuint* fences) { GL_SERVICE_LOG("glDeleteFencesNV" << "(" << n << ", " << static_cast(fences) << ")"); @@ -2546,8 +2653,8 @@ static void GL_BINDING_CALL Debug_glDeleteProgram(GLuint program) { g_driver_gl.debug_fn.glDeleteProgramFn(program); } -static void GL_BINDING_CALL -Debug_glDeleteQueries(GLsizei n, const GLuint* ids) { +static void GL_BINDING_CALL Debug_glDeleteQueries(GLsizei n, + const GLuint* ids) { GL_SERVICE_LOG("glDeleteQueries" << "(" << n << ", " << static_cast(ids) << ")"); g_driver_gl.debug_fn.glDeleteQueriesFn(n, ids); @@ -2561,8 +2668,8 @@ Debug_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers) { g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn(n, renderbuffers); } -static void GL_BINDING_CALL -Debug_glDeleteSamplers(GLsizei n, const GLuint* samplers) { +static void GL_BINDING_CALL Debug_glDeleteSamplers(GLsizei n, + const GLuint* samplers) { GL_SERVICE_LOG("glDeleteSamplers" << "(" << n << ", " << static_cast(samplers) << ")"); @@ -2581,8 +2688,8 @@ static void GL_BINDING_CALL Debug_glDeleteSync(GLsync sync) { g_driver_gl.debug_fn.glDeleteSyncFn(sync); } -static void GL_BINDING_CALL -Debug_glDeleteTextures(GLsizei n, const GLuint* textures) { +static void GL_BINDING_CALL Debug_glDeleteTextures(GLsizei n, + const GLuint* textures) { GL_SERVICE_LOG("glDeleteTextures" << "(" << n << ", " << static_cast(textures) << ")"); @@ -2628,8 +2735,8 @@ static void GL_BINDING_CALL Debug_glDepthRangef(GLclampf zNear, GLclampf zFar) { g_driver_gl.debug_fn.glDepthRangefFn(zNear, zFar); } -static void GL_BINDING_CALL -Debug_glDetachShader(GLuint program, GLuint shader) { +static void GL_BINDING_CALL Debug_glDetachShader(GLuint program, + GLuint shader) { GL_SERVICE_LOG("glDetachShader" << "(" << program << ", " << shader << ")"); g_driver_gl.debug_fn.glDetachShaderFn(program, shader); @@ -2659,8 +2766,9 @@ Debug_glDiscardFramebufferEXT(GLenum target, attachments); } -static void GL_BINDING_CALL -Debug_glDrawArrays(GLenum mode, GLint first, GLsizei count) { +static void GL_BINDING_CALL Debug_glDrawArrays(GLenum mode, + GLint first, + GLsizei count) { GL_SERVICE_LOG("glDrawArrays" << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", " << count << ")"); @@ -2685,8 +2793,8 @@ static void GL_BINDING_CALL Debug_glDrawBuffer(GLenum mode) { g_driver_gl.debug_fn.glDrawBufferFn(mode); } -static void GL_BINDING_CALL -Debug_glDrawBuffersARB(GLsizei n, const GLenum* bufs) { +static void GL_BINDING_CALL Debug_glDrawBuffersARB(GLsizei n, + const GLenum* bufs) { GL_SERVICE_LOG("glDrawBuffersARB" << "(" << n << ", " << static_cast(bufs) << ")"); g_driver_gl.debug_fn.glDrawBuffersARBFn(n, bufs); @@ -2774,8 +2882,8 @@ static void GL_BINDING_CALL Debug_glEndTransformFeedback(void) { g_driver_gl.debug_fn.glEndTransformFeedbackFn(); } -static GLsync GL_BINDING_CALL -Debug_glFenceSync(GLenum condition, GLbitfield flags) { +static GLsync GL_BINDING_CALL Debug_glFenceSync(GLenum condition, + GLbitfield flags) { GL_SERVICE_LOG("glFenceSync" << "(" << GLEnums::GetStringEnum(condition) << ", " << flags << ")"); @@ -2925,8 +3033,8 @@ static void GL_BINDING_CALL Debug_glGenFencesNV(GLsizei n, GLuint* fences) { g_driver_gl.debug_fn.glGenFencesNVFn(n, fences); } -static void GL_BINDING_CALL -Debug_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) { +static void GL_BINDING_CALL Debug_glGenFramebuffersEXT(GLsizei n, + GLuint* framebuffers) { GL_SERVICE_LOG("glGenFramebuffersEXT" << "(" << n << ", " << static_cast(framebuffers) << ")"); @@ -2939,8 +3047,8 @@ static void GL_BINDING_CALL Debug_glGenQueries(GLsizei n, GLuint* ids) { g_driver_gl.debug_fn.glGenQueriesFn(n, ids); } -static void GL_BINDING_CALL -Debug_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) { +static void GL_BINDING_CALL Debug_glGenRenderbuffersEXT(GLsizei n, + GLuint* renderbuffers) { GL_SERVICE_LOG("glGenRenderbuffersEXT" << "(" << n << ", " << static_cast(renderbuffers) << ")"); @@ -2961,15 +3069,15 @@ static void GL_BINDING_CALL Debug_glGenTextures(GLsizei n, GLuint* textures) { g_driver_gl.debug_fn.glGenTexturesFn(n, textures); } -static void GL_BINDING_CALL -Debug_glGenTransformFeedbacks(GLsizei n, GLuint* ids) { +static void GL_BINDING_CALL Debug_glGenTransformFeedbacks(GLsizei n, + GLuint* ids) { GL_SERVICE_LOG("glGenTransformFeedbacks" << "(" << n << ", " << static_cast(ids) << ")"); g_driver_gl.debug_fn.glGenTransformFeedbacksFn(n, ids); } -static void GL_BINDING_CALL -Debug_glGenVertexArraysOES(GLsizei n, GLuint* arrays) { +static void GL_BINDING_CALL Debug_glGenVertexArraysOES(GLsizei n, + GLuint* arrays) { GL_SERVICE_LOG("glGenVertexArraysOES" << "(" << n << ", " << static_cast(arrays) << ")"); @@ -3064,8 +3172,8 @@ static void GL_BINDING_CALL Debug_glGetAttachedShaders(GLuint program, shaders); } -static GLint GL_BINDING_CALL -Debug_glGetAttribLocation(GLuint program, const char* name) { +static GLint GL_BINDING_CALL Debug_glGetAttribLocation(GLuint program, + const char* name) { GL_SERVICE_LOG("glGetAttribLocation" << "(" << program << ", " << name << ")"); GLint result = g_driver_gl.debug_fn.glGetAttribLocationFn(program, name); @@ -3073,16 +3181,17 @@ Debug_glGetAttribLocation(GLuint program, const char* name) { return result; } -static void GL_BINDING_CALL -Debug_glGetBooleanv(GLenum pname, GLboolean* params) { +static void GL_BINDING_CALL Debug_glGetBooleanv(GLenum pname, + GLboolean* params) { GL_SERVICE_LOG("glGetBooleanv" << "(" << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetBooleanvFn(pname, params); } -static void GL_BINDING_CALL -Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetBufferParameteriv(GLenum target, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetBufferParameteriv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -3090,6 +3199,29 @@ Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { g_driver_gl.debug_fn.glGetBufferParameterivFn(target, pname, params); } +static GLuint GL_BINDING_CALL +Debug_glGetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) { + GL_SERVICE_LOG("glGetDebugMessageLogKHR" + << "(" << count << ", " << bufSize << ", " + << static_cast(sources) << ", " + << static_cast(types) << ", " + << static_cast(ids) << ", " + << static_cast(severities) << ", " + << static_cast(lengths) << ", " + << static_cast(messageLog) << ")"); + GLuint result = g_driver_gl.debug_fn.glGetDebugMessageLogKHRFn( + count, bufSize, sources, types, ids, severities, lengths, messageLog); + GL_SERVICE_LOG("GL_RESULT: " << result); + return result; +} + static GLenum GL_BINDING_CALL Debug_glGetError(void) { GL_SERVICE_LOG("glGetError" << "(" @@ -3101,8 +3233,9 @@ static GLenum GL_BINDING_CALL Debug_glGetError(void) { return result; } -static void GL_BINDING_CALL -Debug_glGetFenceivNV(GLuint fence, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetFenceivNV(GLuint fence, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetFenceivNV" << "(" << fence << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); @@ -3116,8 +3249,8 @@ static void GL_BINDING_CALL Debug_glGetFloatv(GLenum pname, GLfloat* params) { g_driver_gl.debug_fn.glGetFloatvFn(pname, params); } -static GLint GL_BINDING_CALL -Debug_glGetFragDataLocation(GLuint program, const char* name) { +static GLint GL_BINDING_CALL Debug_glGetFragDataLocation(GLuint program, + const char* name) { GL_SERVICE_LOG("glGetFragDataLocation" << "(" << program << ", " << name << ")"); GLint result = g_driver_gl.debug_fn.glGetFragDataLocationFn(program, name); @@ -3148,24 +3281,26 @@ static GLenum GL_BINDING_CALL Debug_glGetGraphicsResetStatusARB(void) { return result; } -static void GL_BINDING_CALL -Debug_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data) { +static void GL_BINDING_CALL Debug_glGetInteger64i_v(GLenum target, + GLuint index, + GLint64* data) { GL_SERVICE_LOG("glGetInteger64i_v" << "(" << GLEnums::GetStringEnum(target) << ", " << index << ", " << static_cast(data) << ")"); g_driver_gl.debug_fn.glGetInteger64i_vFn(target, index, data); } -static void GL_BINDING_CALL -Debug_glGetInteger64v(GLenum pname, GLint64* params) { +static void GL_BINDING_CALL Debug_glGetInteger64v(GLenum pname, + GLint64* params) { GL_SERVICE_LOG("glGetInteger64v" << "(" << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetInteger64vFn(pname, params); } -static void GL_BINDING_CALL -Debug_glGetIntegeri_v(GLenum target, GLuint index, GLint* data) { +static void GL_BINDING_CALL Debug_glGetIntegeri_v(GLenum target, + GLuint index, + GLint* data) { GL_SERVICE_LOG("glGetIntegeri_v" << "(" << GLEnums::GetStringEnum(target) << ", " << index << ", " << static_cast(data) << ")"); @@ -3218,8 +3353,9 @@ static void GL_BINDING_CALL Debug_glGetProgramInfoLog(GLuint program, g_driver_gl.debug_fn.glGetProgramInfoLogFn(program, bufsize, length, infolog); } -static void GL_BINDING_CALL -Debug_glGetProgramiv(GLuint program, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetProgramiv(GLuint program, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetProgramiv" << "(" << program << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); @@ -3240,8 +3376,9 @@ Debug_glGetProgramResourceLocation(GLuint program, return result; } -static void GL_BINDING_CALL -Debug_glGetQueryiv(GLenum target, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetQueryiv(GLenum target, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetQueryiv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -3249,32 +3386,36 @@ Debug_glGetQueryiv(GLenum target, GLenum pname, GLint* params) { g_driver_gl.debug_fn.glGetQueryivFn(target, pname, params); } -static void GL_BINDING_CALL -Debug_glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) { +static void GL_BINDING_CALL Debug_glGetQueryObjecti64v(GLuint id, + GLenum pname, + GLint64* params) { GL_SERVICE_LOG("glGetQueryObjecti64v" << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetQueryObjecti64vFn(id, pname, params); } -static void GL_BINDING_CALL -Debug_glGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetQueryObjectiv(GLuint id, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetQueryObjectiv" << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetQueryObjectivFn(id, pname, params); } -static void GL_BINDING_CALL -Debug_glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) { +static void GL_BINDING_CALL Debug_glGetQueryObjectui64v(GLuint id, + GLenum pname, + GLuint64* params) { GL_SERVICE_LOG("glGetQueryObjectui64v" << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetQueryObjectui64vFn(id, pname, params); } -static void GL_BINDING_CALL -Debug_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) { +static void GL_BINDING_CALL Debug_glGetQueryObjectuiv(GLuint id, + GLenum pname, + GLuint* params) { GL_SERVICE_LOG("glGetQueryObjectuiv" << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); @@ -3292,16 +3433,18 @@ Debug_glGetRenderbufferParameterivEXT(GLenum target, g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn(target, pname, params); } -static void GL_BINDING_CALL -Debug_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) { +static void GL_BINDING_CALL Debug_glGetSamplerParameterfv(GLuint sampler, + GLenum pname, + GLfloat* params) { GL_SERVICE_LOG("glGetSamplerParameterfv" << "(" << sampler << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetSamplerParameterfvFn(sampler, pname, params); } -static void GL_BINDING_CALL -Debug_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetSamplerParameteriv(GLuint sampler, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetSamplerParameteriv" << "(" << sampler << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); @@ -3319,8 +3462,9 @@ static void GL_BINDING_CALL Debug_glGetShaderInfoLog(GLuint shader, g_driver_gl.debug_fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog); } -static void GL_BINDING_CALL -Debug_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetShaderiv(GLuint shader, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetShaderiv" << "(" << shader << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); @@ -3360,8 +3504,8 @@ static const GLubyte* GL_BINDING_CALL Debug_glGetString(GLenum name) { return result; } -static const GLubyte* GL_BINDING_CALL -Debug_glGetStringi(GLenum name, GLuint index) { +static const GLubyte* GL_BINDING_CALL Debug_glGetStringi(GLenum name, + GLuint index) { GL_SERVICE_LOG("glGetStringi" << "(" << GLEnums::GetStringEnum(name) << ", " << index << ")"); @@ -3404,8 +3548,9 @@ static void GL_BINDING_CALL Debug_glGetTexLevelParameteriv(GLenum target, g_driver_gl.debug_fn.glGetTexLevelParameterivFn(target, level, pname, params); } -static void GL_BINDING_CALL -Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { +static void GL_BINDING_CALL Debug_glGetTexParameterfv(GLenum target, + GLenum pname, + GLfloat* params) { GL_SERVICE_LOG("glGetTexParameterfv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -3413,8 +3558,9 @@ Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { g_driver_gl.debug_fn.glGetTexParameterfvFn(target, pname, params); } -static void GL_BINDING_CALL -Debug_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetTexParameteriv(GLenum target, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetTexParameteriv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -3462,8 +3608,9 @@ Debug_glGetUniformBlockIndex(GLuint program, const char* uniformBlockName) { return result; } -static void GL_BINDING_CALL -Debug_glGetUniformfv(GLuint program, GLint location, GLfloat* params) { +static void GL_BINDING_CALL Debug_glGetUniformfv(GLuint program, + GLint location, + GLfloat* params) { GL_SERVICE_LOG("glGetUniformfv" << "(" << program << ", " << location << ", " << static_cast(params) << ")"); @@ -3483,16 +3630,17 @@ Debug_glGetUniformIndices(GLuint program, uniformNames, uniformIndices); } -static void GL_BINDING_CALL -Debug_glGetUniformiv(GLuint program, GLint location, GLint* params) { +static void GL_BINDING_CALL Debug_glGetUniformiv(GLuint program, + GLint location, + GLint* params) { GL_SERVICE_LOG("glGetUniformiv" << "(" << program << ", " << location << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetUniformivFn(program, location, params); } -static GLint GL_BINDING_CALL -Debug_glGetUniformLocation(GLuint program, const char* name) { +static GLint GL_BINDING_CALL Debug_glGetUniformLocation(GLuint program, + const char* name) { GL_SERVICE_LOG("glGetUniformLocation" << "(" << program << ", " << name << ")"); GLint result = g_driver_gl.debug_fn.glGetUniformLocationFn(program, name); @@ -3500,24 +3648,27 @@ Debug_glGetUniformLocation(GLuint program, const char* name) { return result; } -static void GL_BINDING_CALL -Debug_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { +static void GL_BINDING_CALL Debug_glGetVertexAttribfv(GLuint index, + GLenum pname, + GLfloat* params) { GL_SERVICE_LOG("glGetVertexAttribfv" << "(" << index << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetVertexAttribfvFn(index, pname, params); } -static void GL_BINDING_CALL -Debug_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { +static void GL_BINDING_CALL Debug_glGetVertexAttribiv(GLuint index, + GLenum pname, + GLint* params) { GL_SERVICE_LOG("glGetVertexAttribiv" << "(" << index << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glGetVertexAttribivFn(index, pname, params); } -static void GL_BINDING_CALL -Debug_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) { +static void GL_BINDING_CALL Debug_glGetVertexAttribPointerv(GLuint index, + GLenum pname, + void** pointer) { GL_SERVICE_LOG("glGetVertexAttribPointerv" << "(" << index << ", " << GLEnums::GetStringEnum(pname) << ", " << pointer << ")"); @@ -3531,8 +3682,8 @@ static void GL_BINDING_CALL Debug_glHint(GLenum target, GLenum mode) { g_driver_gl.debug_fn.glHintFn(target, mode); } -static void GL_BINDING_CALL -Debug_glInsertEventMarkerEXT(GLsizei length, const char* marker) { +static void GL_BINDING_CALL Debug_glInsertEventMarkerEXT(GLsizei length, + const char* marker) { GL_SERVICE_LOG("glInsertEventMarkerEXT" << "(" << length << ", " << marker << ")"); g_driver_gl.debug_fn.glInsertEventMarkerEXTFn(length, marker); @@ -3714,8 +3865,8 @@ static void* GL_BINDING_CALL Debug_glMapBufferRange(GLenum target, return result; } -static void GL_BINDING_CALL -Debug_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) { +static void GL_BINDING_CALL Debug_glMatrixLoadfEXT(GLenum matrixMode, + const GLfloat* m) { GL_SERVICE_LOG("glMatrixLoadfEXT" << "(" << GLEnums::GetStringEnum(matrixMode) << ", " << static_cast(m) << ")"); @@ -3728,6 +3879,17 @@ static void GL_BINDING_CALL Debug_glMatrixLoadIdentityEXT(GLenum matrixMode) { g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn(matrixMode); } +static void GL_BINDING_CALL Debug_glObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) { + GL_SERVICE_LOG("glObjectLabelKHR" + << "(" << GLEnums::GetStringEnum(identifier) << ", " << name + << ", " << length << ", " << static_cast(label) + << ")"); + g_driver_gl.debug_fn.glObjectLabelKHRFn(identifier, name, length, label); +} + static void GL_BINDING_CALL Debug_glPauseTransformFeedback(void) { GL_SERVICE_LOG("glPauseTransformFeedback" << "(" @@ -3749,13 +3911,20 @@ static void GL_BINDING_CALL Debug_glPointParameteri(GLenum pname, GLint param) { g_driver_gl.debug_fn.glPointParameteriFn(pname, param); } -static void GL_BINDING_CALL -Debug_glPolygonOffset(GLfloat factor, GLfloat units) { +static void GL_BINDING_CALL Debug_glPolygonOffset(GLfloat factor, + GLfloat units) { GL_SERVICE_LOG("glPolygonOffset" << "(" << factor << ", " << units << ")"); g_driver_gl.debug_fn.glPolygonOffsetFn(factor, units); } +static void GL_BINDING_CALL Debug_glPopDebugGroupKHR(void) { + GL_SERVICE_LOG("glPopDebugGroupKHR" + << "(" + << ")"); + g_driver_gl.debug_fn.glPopDebugGroupKHRFn(); +} + static void GL_BINDING_CALL Debug_glPopGroupMarkerEXT(void) { GL_SERVICE_LOG("glPopGroupMarkerEXT" << "(" @@ -3774,16 +3943,27 @@ static void GL_BINDING_CALL Debug_glProgramBinary(GLuint program, g_driver_gl.debug_fn.glProgramBinaryFn(program, binaryFormat, binary, length); } -static void GL_BINDING_CALL -Debug_glProgramParameteri(GLuint program, GLenum pname, GLint value) { +static void GL_BINDING_CALL Debug_glProgramParameteri(GLuint program, + GLenum pname, + GLint value) { GL_SERVICE_LOG("glProgramParameteri" << "(" << program << ", " << GLEnums::GetStringEnum(pname) << ", " << value << ")"); g_driver_gl.debug_fn.glProgramParameteriFn(program, pname, value); } -static void GL_BINDING_CALL -Debug_glPushGroupMarkerEXT(GLsizei length, const char* marker) { +static void GL_BINDING_CALL Debug_glPushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) { + GL_SERVICE_LOG("glPushDebugGroupKHR" + << "(" << GLEnums::GetStringEnum(source) << ", " << id << ", " + << length << ", " << static_cast(message) << ")"); + g_driver_gl.debug_fn.glPushDebugGroupKHRFn(source, id, length, message); +} + +static void GL_BINDING_CALL Debug_glPushGroupMarkerEXT(GLsizei length, + const char* marker) { GL_SERVICE_LOG("glPushGroupMarkerEXT" << "(" << length << ", " << marker << ")"); g_driver_gl.debug_fn.glPushGroupMarkerEXTFn(length, marker); @@ -3921,16 +4101,17 @@ static void GL_BINDING_CALL Debug_glResumeTransformFeedback(void) { g_driver_gl.debug_fn.glResumeTransformFeedbackFn(); } -static void GL_BINDING_CALL -Debug_glSampleCoverage(GLclampf value, GLboolean invert) { +static void GL_BINDING_CALL Debug_glSampleCoverage(GLclampf value, + GLboolean invert) { GL_SERVICE_LOG("glSampleCoverage" << "(" << value << ", " << GLEnums::GetStringBool(invert) << ")"); g_driver_gl.debug_fn.glSampleCoverageFn(value, invert); } -static void GL_BINDING_CALL -Debug_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) { +static void GL_BINDING_CALL Debug_glSamplerParameterf(GLuint sampler, + GLenum pname, + GLfloat param) { GL_SERVICE_LOG("glSamplerParameterf" << "(" << sampler << ", " << GLEnums::GetStringEnum(pname) << ", " << param << ")"); @@ -3946,24 +4127,28 @@ static void GL_BINDING_CALL Debug_glSamplerParameterfv(GLuint sampler, g_driver_gl.debug_fn.glSamplerParameterfvFn(sampler, pname, params); } -static void GL_BINDING_CALL -Debug_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) { +static void GL_BINDING_CALL Debug_glSamplerParameteri(GLuint sampler, + GLenum pname, + GLint param) { GL_SERVICE_LOG("glSamplerParameteri" << "(" << sampler << ", " << GLEnums::GetStringEnum(pname) << ", " << param << ")"); g_driver_gl.debug_fn.glSamplerParameteriFn(sampler, pname, param); } -static void GL_BINDING_CALL -Debug_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* params) { +static void GL_BINDING_CALL Debug_glSamplerParameteriv(GLuint sampler, + GLenum pname, + const GLint* params) { GL_SERVICE_LOG("glSamplerParameteriv" << "(" << sampler << ", " << GLEnums::GetStringEnum(pname) << ", " << static_cast(params) << ")"); g_driver_gl.debug_fn.glSamplerParameterivFn(sampler, pname, params); } -static void GL_BINDING_CALL -Debug_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { +static void GL_BINDING_CALL Debug_glScissor(GLint x, + GLint y, + GLsizei width, + GLsizei height) { GL_SERVICE_LOG("glScissor" << "(" << x << ", " << y << ", " << width << ", " << height << ")"); @@ -4022,16 +4207,19 @@ static void GL_BINDING_CALL Debug_glShaderSource(GLuint shader, }); } -static void GL_BINDING_CALL -Debug_glStencilFunc(GLenum func, GLint ref, GLuint mask) { +static void GL_BINDING_CALL Debug_glStencilFunc(GLenum func, + GLint ref, + GLuint mask) { GL_SERVICE_LOG("glStencilFunc" << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", " << mask << ")"); g_driver_gl.debug_fn.glStencilFuncFn(func, ref, mask); } -static void GL_BINDING_CALL -Debug_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { +static void GL_BINDING_CALL Debug_glStencilFuncSeparate(GLenum face, + GLenum func, + GLint ref, + GLuint mask) { GL_SERVICE_LOG("glStencilFuncSeparate" << "(" << GLEnums::GetStringEnum(face) << ", " << GLEnums::GetStringEnum(func) << ", " << ref << ", " << mask @@ -4045,15 +4233,16 @@ static void GL_BINDING_CALL Debug_glStencilMask(GLuint mask) { g_driver_gl.debug_fn.glStencilMaskFn(mask); } -static void GL_BINDING_CALL -Debug_glStencilMaskSeparate(GLenum face, GLuint mask) { +static void GL_BINDING_CALL Debug_glStencilMaskSeparate(GLenum face, + GLuint mask) { GL_SERVICE_LOG("glStencilMaskSeparate" << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")"); g_driver_gl.debug_fn.glStencilMaskSeparateFn(face, mask); } -static void GL_BINDING_CALL -Debug_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { +static void GL_BINDING_CALL Debug_glStencilOp(GLenum fail, + GLenum zfail, + GLenum zpass) { GL_SERVICE_LOG("glStencilOp" << "(" << GLEnums::GetStringEnum(fail) << ", " << GLEnums::GetStringEnum(zfail) << ", " @@ -4130,16 +4319,18 @@ static void GL_BINDING_CALL Debug_glTexImage3D(GLenum target, pixels); } -static void GL_BINDING_CALL -Debug_glTexParameterf(GLenum target, GLenum pname, GLfloat param) { +static void GL_BINDING_CALL Debug_glTexParameterf(GLenum target, + GLenum pname, + GLfloat param) { GL_SERVICE_LOG("glTexParameterf" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " << param << ")"); g_driver_gl.debug_fn.glTexParameterfFn(target, pname, param); } -static void GL_BINDING_CALL -Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { +static void GL_BINDING_CALL Debug_glTexParameterfv(GLenum target, + GLenum pname, + const GLfloat* params) { GL_SERVICE_LOG("glTexParameterfv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -4147,16 +4338,18 @@ Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { g_driver_gl.debug_fn.glTexParameterfvFn(target, pname, params); } -static void GL_BINDING_CALL -Debug_glTexParameteri(GLenum target, GLenum pname, GLint param) { +static void GL_BINDING_CALL Debug_glTexParameteri(GLenum target, + GLenum pname, + GLint param) { GL_SERVICE_LOG("glTexParameteri" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " << param << ")"); g_driver_gl.debug_fn.glTexParameteriFn(target, pname, param); } -static void GL_BINDING_CALL -Debug_glTexParameteriv(GLenum target, GLenum pname, const GLint* params) { +static void GL_BINDING_CALL Debug_glTexParameteriv(GLenum target, + GLenum pname, + const GLint* params) { GL_SERVICE_LOG("glTexParameteriv" << "(" << GLEnums::GetStringEnum(target) << ", " << GLEnums::GetStringEnum(pname) << ", " @@ -4229,8 +4422,9 @@ static void GL_BINDING_CALL Debug_glUniform1f(GLint location, GLfloat x) { g_driver_gl.debug_fn.glUniform1fFn(location, x); } -static void GL_BINDING_CALL -Debug_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) { +static void GL_BINDING_CALL Debug_glUniform1fv(GLint location, + GLsizei count, + const GLfloat* v) { GL_SERVICE_LOG("glUniform1fv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4243,8 +4437,9 @@ static void GL_BINDING_CALL Debug_glUniform1i(GLint location, GLint x) { g_driver_gl.debug_fn.glUniform1iFn(location, x); } -static void GL_BINDING_CALL -Debug_glUniform1iv(GLint location, GLsizei count, const GLint* v) { +static void GL_BINDING_CALL Debug_glUniform1iv(GLint location, + GLsizei count, + const GLint* v) { GL_SERVICE_LOG("glUniform1iv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4257,101 +4452,117 @@ static void GL_BINDING_CALL Debug_glUniform1ui(GLint location, GLuint v0) { g_driver_gl.debug_fn.glUniform1uiFn(location, v0); } -static void GL_BINDING_CALL -Debug_glUniform1uiv(GLint location, GLsizei count, const GLuint* v) { +static void GL_BINDING_CALL Debug_glUniform1uiv(GLint location, + GLsizei count, + const GLuint* v) { GL_SERVICE_LOG("glUniform1uiv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform1uivFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform2f(GLint location, GLfloat x, GLfloat y) { +static void GL_BINDING_CALL Debug_glUniform2f(GLint location, + GLfloat x, + GLfloat y) { GL_SERVICE_LOG("glUniform2f" << "(" << location << ", " << x << ", " << y << ")"); g_driver_gl.debug_fn.glUniform2fFn(location, x, y); } -static void GL_BINDING_CALL -Debug_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) { +static void GL_BINDING_CALL Debug_glUniform2fv(GLint location, + GLsizei count, + const GLfloat* v) { GL_SERVICE_LOG("glUniform2fv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform2fvFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform2i(GLint location, GLint x, GLint y) { +static void GL_BINDING_CALL Debug_glUniform2i(GLint location, + GLint x, + GLint y) { GL_SERVICE_LOG("glUniform2i" << "(" << location << ", " << x << ", " << y << ")"); g_driver_gl.debug_fn.glUniform2iFn(location, x, y); } -static void GL_BINDING_CALL -Debug_glUniform2iv(GLint location, GLsizei count, const GLint* v) { +static void GL_BINDING_CALL Debug_glUniform2iv(GLint location, + GLsizei count, + const GLint* v) { GL_SERVICE_LOG("glUniform2iv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform2ivFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform2ui(GLint location, GLuint v0, GLuint v1) { +static void GL_BINDING_CALL Debug_glUniform2ui(GLint location, + GLuint v0, + GLuint v1) { GL_SERVICE_LOG("glUniform2ui" << "(" << location << ", " << v0 << ", " << v1 << ")"); g_driver_gl.debug_fn.glUniform2uiFn(location, v0, v1); } -static void GL_BINDING_CALL -Debug_glUniform2uiv(GLint location, GLsizei count, const GLuint* v) { +static void GL_BINDING_CALL Debug_glUniform2uiv(GLint location, + GLsizei count, + const GLuint* v) { GL_SERVICE_LOG("glUniform2uiv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform2uivFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { +static void GL_BINDING_CALL Debug_glUniform3f(GLint location, + GLfloat x, + GLfloat y, + GLfloat z) { GL_SERVICE_LOG("glUniform3f" << "(" << location << ", " << x << ", " << y << ", " << z << ")"); g_driver_gl.debug_fn.glUniform3fFn(location, x, y, z); } -static void GL_BINDING_CALL -Debug_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) { +static void GL_BINDING_CALL Debug_glUniform3fv(GLint location, + GLsizei count, + const GLfloat* v) { GL_SERVICE_LOG("glUniform3fv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform3fvFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform3i(GLint location, GLint x, GLint y, GLint z) { +static void GL_BINDING_CALL Debug_glUniform3i(GLint location, + GLint x, + GLint y, + GLint z) { GL_SERVICE_LOG("glUniform3i" << "(" << location << ", " << x << ", " << y << ", " << z << ")"); g_driver_gl.debug_fn.glUniform3iFn(location, x, y, z); } -static void GL_BINDING_CALL -Debug_glUniform3iv(GLint location, GLsizei count, const GLint* v) { +static void GL_BINDING_CALL Debug_glUniform3iv(GLint location, + GLsizei count, + const GLint* v) { GL_SERVICE_LOG("glUniform3iv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); g_driver_gl.debug_fn.glUniform3ivFn(location, count, v); } -static void GL_BINDING_CALL -Debug_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) { +static void GL_BINDING_CALL Debug_glUniform3ui(GLint location, + GLuint v0, + GLuint v1, + GLuint v2) { GL_SERVICE_LOG("glUniform3ui" << "(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ")"); g_driver_gl.debug_fn.glUniform3uiFn(location, v0, v1, v2); } -static void GL_BINDING_CALL -Debug_glUniform3uiv(GLint location, GLsizei count, const GLuint* v) { +static void GL_BINDING_CALL Debug_glUniform3uiv(GLint location, + GLsizei count, + const GLuint* v) { GL_SERVICE_LOG("glUniform3uiv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4366,8 +4577,9 @@ Debug_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { g_driver_gl.debug_fn.glUniform4fFn(location, x, y, z, w); } -static void GL_BINDING_CALL -Debug_glUniform4fv(GLint location, GLsizei count, const GLfloat* v) { +static void GL_BINDING_CALL Debug_glUniform4fv(GLint location, + GLsizei count, + const GLfloat* v) { GL_SERVICE_LOG("glUniform4fv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4382,8 +4594,9 @@ Debug_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { g_driver_gl.debug_fn.glUniform4iFn(location, x, y, z, w); } -static void GL_BINDING_CALL -Debug_glUniform4iv(GLint location, GLsizei count, const GLint* v) { +static void GL_BINDING_CALL Debug_glUniform4iv(GLint location, + GLsizei count, + const GLint* v) { GL_SERVICE_LOG("glUniform4iv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4398,8 +4611,9 @@ Debug_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { g_driver_gl.debug_fn.glUniform4uiFn(location, v0, v1, v2, v3); } -static void GL_BINDING_CALL -Debug_glUniform4uiv(GLint location, GLsizei count, const GLuint* v) { +static void GL_BINDING_CALL Debug_glUniform4uiv(GLint location, + GLsizei count, + const GLuint* v) { GL_SERVICE_LOG("glUniform4uiv" << "(" << location << ", " << count << ", " << static_cast(v) << ")"); @@ -4548,38 +4762,41 @@ static void GL_BINDING_CALL Debug_glVertexAttrib1f(GLuint indx, GLfloat x) { g_driver_gl.debug_fn.glVertexAttrib1fFn(indx, x); } -static void GL_BINDING_CALL -Debug_glVertexAttrib1fv(GLuint indx, const GLfloat* values) { +static void GL_BINDING_CALL Debug_glVertexAttrib1fv(GLuint indx, + const GLfloat* values) { GL_SERVICE_LOG("glVertexAttrib1fv" << "(" << indx << ", " << static_cast(values) << ")"); g_driver_gl.debug_fn.glVertexAttrib1fvFn(indx, values); } -static void GL_BINDING_CALL -Debug_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { +static void GL_BINDING_CALL Debug_glVertexAttrib2f(GLuint indx, + GLfloat x, + GLfloat y) { GL_SERVICE_LOG("glVertexAttrib2f" << "(" << indx << ", " << x << ", " << y << ")"); g_driver_gl.debug_fn.glVertexAttrib2fFn(indx, x, y); } -static void GL_BINDING_CALL -Debug_glVertexAttrib2fv(GLuint indx, const GLfloat* values) { +static void GL_BINDING_CALL Debug_glVertexAttrib2fv(GLuint indx, + const GLfloat* values) { GL_SERVICE_LOG("glVertexAttrib2fv" << "(" << indx << ", " << static_cast(values) << ")"); g_driver_gl.debug_fn.glVertexAttrib2fvFn(indx, values); } -static void GL_BINDING_CALL -Debug_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { +static void GL_BINDING_CALL Debug_glVertexAttrib3f(GLuint indx, + GLfloat x, + GLfloat y, + GLfloat z) { GL_SERVICE_LOG("glVertexAttrib3f" << "(" << indx << ", " << x << ", " << y << ", " << z << ")"); g_driver_gl.debug_fn.glVertexAttrib3fFn(indx, x, y, z); } -static void GL_BINDING_CALL -Debug_glVertexAttrib3fv(GLuint indx, const GLfloat* values) { +static void GL_BINDING_CALL Debug_glVertexAttrib3fv(GLuint indx, + const GLfloat* values) { GL_SERVICE_LOG("glVertexAttrib3fv" << "(" << indx << ", " << static_cast(values) << ")"); @@ -4597,16 +4814,16 @@ static void GL_BINDING_CALL Debug_glVertexAttrib4f(GLuint indx, g_driver_gl.debug_fn.glVertexAttrib4fFn(indx, x, y, z, w); } -static void GL_BINDING_CALL -Debug_glVertexAttrib4fv(GLuint indx, const GLfloat* values) { +static void GL_BINDING_CALL Debug_glVertexAttrib4fv(GLuint indx, + const GLfloat* values) { GL_SERVICE_LOG("glVertexAttrib4fv" << "(" << indx << ", " << static_cast(values) << ")"); g_driver_gl.debug_fn.glVertexAttrib4fvFn(indx, values); } -static void GL_BINDING_CALL -Debug_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) { +static void GL_BINDING_CALL Debug_glVertexAttribDivisorANGLE(GLuint index, + GLuint divisor) { GL_SERVICE_LOG("glVertexAttribDivisorANGLE" << "(" << index << ", " << divisor << ")"); g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn(index, divisor); @@ -4620,8 +4837,8 @@ Debug_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) { g_driver_gl.debug_fn.glVertexAttribI4iFn(indx, x, y, z, w); } -static void GL_BINDING_CALL -Debug_glVertexAttribI4iv(GLuint indx, const GLint* values) { +static void GL_BINDING_CALL Debug_glVertexAttribI4iv(GLuint indx, + const GLint* values) { GL_SERVICE_LOG("glVertexAttribI4iv" << "(" << indx << ", " << static_cast(values) << ")"); @@ -4636,8 +4853,8 @@ Debug_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) { g_driver_gl.debug_fn.glVertexAttribI4uiFn(indx, x, y, z, w); } -static void GL_BINDING_CALL -Debug_glVertexAttribI4uiv(GLuint indx, const GLuint* values) { +static void GL_BINDING_CALL Debug_glVertexAttribI4uiv(GLuint indx, + const GLuint* values) { GL_SERVICE_LOG("glVertexAttribI4uiv" << "(" << indx << ", " << static_cast(values) << ")"); @@ -4671,16 +4888,19 @@ static void GL_BINDING_CALL Debug_glVertexAttribPointer(GLuint indx, stride, ptr); } -static void GL_BINDING_CALL -Debug_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { +static void GL_BINDING_CALL Debug_glViewport(GLint x, + GLint y, + GLsizei width, + GLsizei height) { GL_SERVICE_LOG("glViewport" << "(" << x << ", " << y << ", " << width << ", " << height << ")"); g_driver_gl.debug_fn.glViewportFn(x, y, width, height); } -static GLenum GL_BINDING_CALL -Debug_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { +static GLenum GL_BINDING_CALL Debug_glWaitSync(GLsync sync, + GLbitfield flags, + GLuint64 timeout) { GL_SERVICE_LOG("glWaitSync" << "(" << sync << ", " << flags << ", " << timeout << ")"); GLenum result = g_driver_gl.debug_fn.glWaitSyncFn(sync, flags, timeout); @@ -4891,6 +5111,18 @@ void DriverGL::InitializeDebugBindings() { debug_fn.glCullFaceFn = fn.glCullFaceFn; fn.glCullFaceFn = Debug_glCullFace; } + if (!debug_fn.glDebugMessageCallbackKHRFn) { + debug_fn.glDebugMessageCallbackKHRFn = fn.glDebugMessageCallbackKHRFn; + fn.glDebugMessageCallbackKHRFn = Debug_glDebugMessageCallbackKHR; + } + if (!debug_fn.glDebugMessageControlKHRFn) { + debug_fn.glDebugMessageControlKHRFn = fn.glDebugMessageControlKHRFn; + fn.glDebugMessageControlKHRFn = Debug_glDebugMessageControlKHR; + } + if (!debug_fn.glDebugMessageInsertKHRFn) { + debug_fn.glDebugMessageInsertKHRFn = fn.glDebugMessageInsertKHRFn; + fn.glDebugMessageInsertKHRFn = Debug_glDebugMessageInsertKHR; + } if (!debug_fn.glDeleteBuffersARBFn) { debug_fn.glDeleteBuffersARBFn = fn.glDeleteBuffersARBFn; fn.glDeleteBuffersARBFn = Debug_glDeleteBuffersARB; @@ -5161,6 +5393,10 @@ void DriverGL::InitializeDebugBindings() { debug_fn.glGetBufferParameterivFn = fn.glGetBufferParameterivFn; fn.glGetBufferParameterivFn = Debug_glGetBufferParameteriv; } + if (!debug_fn.glGetDebugMessageLogKHRFn) { + debug_fn.glGetDebugMessageLogKHRFn = fn.glGetDebugMessageLogKHRFn; + fn.glGetDebugMessageLogKHRFn = Debug_glGetDebugMessageLogKHR; + } if (!debug_fn.glGetErrorFn) { debug_fn.glGetErrorFn = fn.glGetErrorFn; fn.glGetErrorFn = Debug_glGetError; @@ -5440,6 +5676,10 @@ void DriverGL::InitializeDebugBindings() { debug_fn.glMatrixLoadIdentityEXTFn = fn.glMatrixLoadIdentityEXTFn; fn.glMatrixLoadIdentityEXTFn = Debug_glMatrixLoadIdentityEXT; } + if (!debug_fn.glObjectLabelKHRFn) { + debug_fn.glObjectLabelKHRFn = fn.glObjectLabelKHRFn; + fn.glObjectLabelKHRFn = Debug_glObjectLabelKHR; + } if (!debug_fn.glPauseTransformFeedbackFn) { debug_fn.glPauseTransformFeedbackFn = fn.glPauseTransformFeedbackFn; fn.glPauseTransformFeedbackFn = Debug_glPauseTransformFeedback; @@ -5456,6 +5696,10 @@ void DriverGL::InitializeDebugBindings() { debug_fn.glPolygonOffsetFn = fn.glPolygonOffsetFn; fn.glPolygonOffsetFn = Debug_glPolygonOffset; } + if (!debug_fn.glPopDebugGroupKHRFn) { + debug_fn.glPopDebugGroupKHRFn = fn.glPopDebugGroupKHRFn; + fn.glPopDebugGroupKHRFn = Debug_glPopDebugGroupKHR; + } if (!debug_fn.glPopGroupMarkerEXTFn) { debug_fn.glPopGroupMarkerEXTFn = fn.glPopGroupMarkerEXTFn; fn.glPopGroupMarkerEXTFn = Debug_glPopGroupMarkerEXT; @@ -5468,6 +5712,10 @@ void DriverGL::InitializeDebugBindings() { debug_fn.glProgramParameteriFn = fn.glProgramParameteriFn; fn.glProgramParameteriFn = Debug_glProgramParameteri; } + if (!debug_fn.glPushDebugGroupKHRFn) { + debug_fn.glPushDebugGroupKHRFn = fn.glPushDebugGroupKHRFn; + fn.glPushDebugGroupKHRFn = Debug_glPushDebugGroupKHR; + } if (!debug_fn.glPushGroupMarkerEXTFn) { debug_fn.glPushGroupMarkerEXTFn = fn.glPushGroupMarkerEXTFn; fn.glPushGroupMarkerEXTFn = Debug_glPushGroupMarkerEXT; @@ -6194,6 +6442,31 @@ void GLApiBase::glCullFaceFn(GLenum mode) { driver_->fn.glCullFaceFn(mode); } +void GLApiBase::glDebugMessageCallbackKHRFn(GLDEBUGPROCKHR callback, + const void* userparam) { + driver_->fn.glDebugMessageCallbackKHRFn(callback, userparam); +} + +void GLApiBase::glDebugMessageControlKHRFn(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) { + driver_->fn.glDebugMessageControlKHRFn(source, type, severity, count, ids, + enabled); +} + +void GLApiBase::glDebugMessageInsertKHRFn(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) { + driver_->fn.glDebugMessageInsertKHRFn(source, type, id, severity, length, + buf); +} + void GLApiBase::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) { driver_->fn.glDeleteBuffersARBFn(n, buffers); } @@ -6541,6 +6814,18 @@ void GLApiBase::glGetBufferParameterivFn(GLenum target, driver_->fn.glGetBufferParameterivFn(target, pname, params); } +GLuint GLApiBase::glGetDebugMessageLogKHRFn(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) { + return driver_->fn.glGetDebugMessageLogKHRFn( + count, bufSize, sources, types, ids, severities, lengths, messageLog); +} + GLenum GLApiBase::glGetErrorFn(void) { return driver_->fn.glGetErrorFn(); } @@ -6907,6 +7192,13 @@ void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) { driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode); } +void GLApiBase::glObjectLabelKHRFn(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) { + driver_->fn.glObjectLabelKHRFn(identifier, name, length, label); +} + void GLApiBase::glPauseTransformFeedbackFn(void) { driver_->fn.glPauseTransformFeedbackFn(); } @@ -6923,6 +7215,10 @@ void GLApiBase::glPolygonOffsetFn(GLfloat factor, GLfloat units) { driver_->fn.glPolygonOffsetFn(factor, units); } +void GLApiBase::glPopDebugGroupKHRFn(void) { + driver_->fn.glPopDebugGroupKHRFn(); +} + void GLApiBase::glPopGroupMarkerEXTFn(void) { driver_->fn.glPopGroupMarkerEXTFn(); } @@ -6940,6 +7236,13 @@ void GLApiBase::glProgramParameteriFn(GLuint program, driver_->fn.glProgramParameteriFn(program, pname, value); } +void GLApiBase::glPushDebugGroupKHRFn(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) { + driver_->fn.glPushDebugGroupKHRFn(source, id, length, message); +} + void GLApiBase::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) { driver_->fn.glPushGroupMarkerEXTFn(length, marker); } @@ -7890,6 +8193,33 @@ void TraceGLApi::glCullFaceFn(GLenum mode) { gl_api_->glCullFaceFn(mode); } +void TraceGLApi::glDebugMessageCallbackKHRFn(GLDEBUGPROCKHR callback, + const void* userparam) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageCallbackKHR") + gl_api_->glDebugMessageCallbackKHRFn(callback, userparam); +} + +void TraceGLApi::glDebugMessageControlKHRFn(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageControlKHR") + gl_api_->glDebugMessageControlKHRFn(source, type, severity, count, ids, + enabled); +} + +void TraceGLApi::glDebugMessageInsertKHRFn(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageInsertKHR") + gl_api_->glDebugMessageInsertKHRFn(source, type, id, severity, length, buf); +} + void TraceGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteBuffersARB") gl_api_->glDeleteBuffersARBFn(n, buffers); @@ -8310,6 +8640,19 @@ void TraceGLApi::glGetBufferParameterivFn(GLenum target, gl_api_->glGetBufferParameterivFn(target, pname, params); } +GLuint TraceGLApi::glGetDebugMessageLogKHRFn(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetDebugMessageLogKHR") + return gl_api_->glGetDebugMessageLogKHRFn(count, bufSize, sources, types, ids, + severities, lengths, messageLog); +} + GLenum TraceGLApi::glGetErrorFn(void) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetError") return gl_api_->glGetErrorFn(); @@ -8750,6 +9093,14 @@ void TraceGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) { gl_api_->glMatrixLoadIdentityEXTFn(matrixMode); } +void TraceGLApi::glObjectLabelKHRFn(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glObjectLabelKHR") + gl_api_->glObjectLabelKHRFn(identifier, name, length, label); +} + void TraceGLApi::glPauseTransformFeedbackFn(void) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPauseTransformFeedback") gl_api_->glPauseTransformFeedbackFn(); @@ -8770,6 +9121,11 @@ void TraceGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) { gl_api_->glPolygonOffsetFn(factor, units); } +void TraceGLApi::glPopDebugGroupKHRFn(void) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopDebugGroupKHR") + gl_api_->glPopDebugGroupKHRFn(); +} + void TraceGLApi::glPopGroupMarkerEXTFn(void) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopGroupMarkerEXT") gl_api_->glPopGroupMarkerEXTFn(); @@ -8790,6 +9146,14 @@ void TraceGLApi::glProgramParameteriFn(GLuint program, gl_api_->glProgramParameteriFn(program, pname, value); } +void TraceGLApi::glPushDebugGroupKHRFn(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) { + TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPushDebugGroupKHR") + gl_api_->glPushDebugGroupKHRFn(source, id, length, message); +} + void TraceGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) { TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPushGroupMarkerEXT") gl_api_->glPushGroupMarkerEXTFn(length, marker); @@ -9881,6 +10245,38 @@ void NoContextGLApi::glCullFaceFn(GLenum mode) { LOG(ERROR) << "Trying to call glCullFace() without current GL context"; } +void NoContextGLApi::glDebugMessageCallbackKHRFn(GLDEBUGPROCKHR callback, + const void* userparam) { + NOTREACHED() << "Trying to call glDebugMessageCallbackKHR() without current " + "GL context"; + LOG(ERROR) << "Trying to call glDebugMessageCallbackKHR() without current GL " + "context"; +} + +void NoContextGLApi::glDebugMessageControlKHRFn(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) { + NOTREACHED() + << "Trying to call glDebugMessageControlKHR() without current GL context"; + LOG(ERROR) + << "Trying to call glDebugMessageControlKHR() without current GL context"; +} + +void NoContextGLApi::glDebugMessageInsertKHRFn(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) { + NOTREACHED() + << "Trying to call glDebugMessageInsertKHR() without current GL context"; + LOG(ERROR) + << "Trying to call glDebugMessageInsertKHR() without current GL context"; +} + void NoContextGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) { NOTREACHED() << "Trying to call glDeleteBuffersARB() without current GL context"; @@ -10362,6 +10758,21 @@ void NoContextGLApi::glGetBufferParameterivFn(GLenum target, << "Trying to call glGetBufferParameteriv() without current GL context"; } +GLuint NoContextGLApi::glGetDebugMessageLogKHRFn(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) { + NOTREACHED() + << "Trying to call glGetDebugMessageLogKHR() without current GL context"; + LOG(ERROR) + << "Trying to call glGetDebugMessageLogKHR() without current GL context"; + return 0U; +} + GLenum NoContextGLApi::glGetErrorFn(void) { NOTREACHED() << "Trying to call glGetError() without current GL context"; LOG(ERROR) << "Trying to call glGetError() without current GL context"; @@ -10904,6 +11315,15 @@ void NoContextGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) { << "Trying to call glMatrixLoadIdentityEXT() without current GL context"; } +void NoContextGLApi::glObjectLabelKHRFn(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) { + NOTREACHED() + << "Trying to call glObjectLabelKHR() without current GL context"; + LOG(ERROR) << "Trying to call glObjectLabelKHR() without current GL context"; +} + void NoContextGLApi::glPauseTransformFeedbackFn(void) { NOTREACHED() << "Trying to call glPauseTransformFeedback() without current GL context"; @@ -10927,6 +11347,13 @@ void NoContextGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) { LOG(ERROR) << "Trying to call glPolygonOffset() without current GL context"; } +void NoContextGLApi::glPopDebugGroupKHRFn(void) { + NOTREACHED() + << "Trying to call glPopDebugGroupKHR() without current GL context"; + LOG(ERROR) + << "Trying to call glPopDebugGroupKHR() without current GL context"; +} + void NoContextGLApi::glPopGroupMarkerEXTFn(void) { NOTREACHED() << "Trying to call glPopGroupMarkerEXT() without current GL context"; @@ -10951,6 +11378,16 @@ void NoContextGLApi::glProgramParameteriFn(GLuint program, << "Trying to call glProgramParameteri() without current GL context"; } +void NoContextGLApi::glPushDebugGroupKHRFn(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) { + NOTREACHED() + << "Trying to call glPushDebugGroupKHR() without current GL context"; + LOG(ERROR) + << "Trying to call glPushDebugGroupKHR() without current GL context"; +} + void NoContextGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) { NOTREACHED() diff --git a/ui/gl/gl_bindings_autogen_gl.h b/ui/gl/gl_bindings_autogen_gl.h index b501a707952..017e31a133e 100644 --- a/ui/gl/gl_bindings_autogen_gl.h +++ b/ui/gl/gl_bindings_autogen_gl.h @@ -190,6 +190,21 @@ typedef void(GL_BINDING_CALL* glCopyTexSubImage3DProc)(GLenum target, typedef GLuint(GL_BINDING_CALL* glCreateProgramProc)(void); typedef GLuint(GL_BINDING_CALL* glCreateShaderProc)(GLenum type); typedef void(GL_BINDING_CALL* glCullFaceProc)(GLenum mode); +typedef void(GL_BINDING_CALL* glDebugMessageCallbackKHRProc)( + GLDEBUGPROCKHR callback, + const void* userparam); +typedef void(GL_BINDING_CALL* glDebugMessageControlKHRProc)(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled); +typedef void(GL_BINDING_CALL* glDebugMessageInsertKHRProc)(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf); typedef void(GL_BINDING_CALL* glDeleteBuffersARBProc)(GLsizei n, const GLuint* buffers); typedef void(GL_BINDING_CALL* glDeleteFencesAPPLEProc)(GLsizei n, @@ -362,6 +377,15 @@ typedef void(GL_BINDING_CALL* glGetBooleanvProc)(GLenum pname, typedef void(GL_BINDING_CALL* glGetBufferParameterivProc)(GLenum target, GLenum pname, GLint* params); +typedef GLuint(GL_BINDING_CALL* glGetDebugMessageLogKHRProc)( + GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog); typedef GLenum(GL_BINDING_CALL* glGetErrorProc)(void); typedef void(GL_BINDING_CALL* glGetFenceivNVProc)(GLuint fence, GLenum pname, @@ -546,11 +570,16 @@ typedef void*(GL_BINDING_CALL* glMapBufferRangeProc)(GLenum target, typedef void(GL_BINDING_CALL* glMatrixLoadfEXTProc)(GLenum matrixMode, const GLfloat* m); typedef void(GL_BINDING_CALL* glMatrixLoadIdentityEXTProc)(GLenum matrixMode); +typedef void(GL_BINDING_CALL* glObjectLabelKHRProc)(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label); typedef void(GL_BINDING_CALL* glPauseTransformFeedbackProc)(void); typedef void(GL_BINDING_CALL* glPixelStoreiProc)(GLenum pname, GLint param); typedef void(GL_BINDING_CALL* glPointParameteriProc)(GLenum pname, GLint param); typedef void(GL_BINDING_CALL* glPolygonOffsetProc)(GLfloat factor, GLfloat units); +typedef void(GL_BINDING_CALL* glPopDebugGroupKHRProc)(void); typedef void(GL_BINDING_CALL* glPopGroupMarkerEXTProc)(void); typedef void(GL_BINDING_CALL* glProgramBinaryProc)(GLuint program, GLenum binaryFormat, @@ -559,6 +588,10 @@ typedef void(GL_BINDING_CALL* glProgramBinaryProc)(GLuint program, typedef void(GL_BINDING_CALL* glProgramParameteriProc)(GLuint program, GLenum pname, GLint value); +typedef void(GL_BINDING_CALL* glPushDebugGroupKHRProc)(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message); typedef void(GL_BINDING_CALL* glPushGroupMarkerEXTProc)(GLsizei length, const char* marker); typedef void(GL_BINDING_CALL* glQueryCounterProc)(GLuint id, GLenum target); @@ -922,6 +955,7 @@ struct ExtensionsGL { bool b_GL_EXT_timer_query; bool b_GL_IMG_multisampled_render_to_texture; bool b_GL_KHR_blend_equation_advanced; + bool b_GL_KHR_debug; bool b_GL_KHR_robustness; bool b_GL_NV_blend_equation_advanced; bool b_GL_NV_fence; @@ -983,6 +1017,9 @@ struct ProcsGL { glCreateProgramProc glCreateProgramFn; glCreateShaderProc glCreateShaderFn; glCullFaceProc glCullFaceFn; + glDebugMessageCallbackKHRProc glDebugMessageCallbackKHRFn; + glDebugMessageControlKHRProc glDebugMessageControlKHRFn; + glDebugMessageInsertKHRProc glDebugMessageInsertKHRFn; glDeleteBuffersARBProc glDeleteBuffersARBFn; glDeleteFencesAPPLEProc glDeleteFencesAPPLEFn; glDeleteFencesNVProc glDeleteFencesNVFn; @@ -1052,6 +1089,7 @@ struct ProcsGL { glGetAttribLocationProc glGetAttribLocationFn; glGetBooleanvProc glGetBooleanvFn; glGetBufferParameterivProc glGetBufferParameterivFn; + glGetDebugMessageLogKHRProc glGetDebugMessageLogKHRFn; glGetErrorProc glGetErrorFn; glGetFenceivNVProc glGetFenceivNVFn; glGetFloatvProc glGetFloatvFn; @@ -1121,13 +1159,16 @@ struct ProcsGL { glMapBufferRangeProc glMapBufferRangeFn; glMatrixLoadfEXTProc glMatrixLoadfEXTFn; glMatrixLoadIdentityEXTProc glMatrixLoadIdentityEXTFn; + glObjectLabelKHRProc glObjectLabelKHRFn; glPauseTransformFeedbackProc glPauseTransformFeedbackFn; glPixelStoreiProc glPixelStoreiFn; glPointParameteriProc glPointParameteriFn; glPolygonOffsetProc glPolygonOffsetFn; + glPopDebugGroupKHRProc glPopDebugGroupKHRFn; glPopGroupMarkerEXTProc glPopGroupMarkerEXTFn; glProgramBinaryProc glProgramBinaryFn; glProgramParameteriProc glProgramParameteriFn; + glPushDebugGroupKHRProc glPushDebugGroupKHRFn; glPushGroupMarkerEXTProc glPushGroupMarkerEXTFn; glQueryCounterProc glQueryCounterFn; glReadBufferProc glReadBufferFn; @@ -1401,6 +1442,20 @@ class GL_EXPORT GLApi { virtual GLuint glCreateProgramFn(void) = 0; virtual GLuint glCreateShaderFn(GLenum type) = 0; virtual void glCullFaceFn(GLenum mode) = 0; + virtual void glDebugMessageCallbackKHRFn(GLDEBUGPROCKHR callback, + const void* userparam) = 0; + virtual void glDebugMessageControlKHRFn(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) = 0; + virtual void glDebugMessageInsertKHRFn(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) = 0; virtual void glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) = 0; virtual void glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) = 0; virtual void glDeleteFencesNVFn(GLsizei n, const GLuint* fences) = 0; @@ -1540,6 +1595,14 @@ class GL_EXPORT GLApi { virtual void glGetBufferParameterivFn(GLenum target, GLenum pname, GLint* params) = 0; + virtual GLuint glGetDebugMessageLogKHRFn(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) = 0; virtual GLenum glGetErrorFn(void) = 0; virtual void glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) = 0; virtual void glGetFloatvFn(GLenum pname, GLfloat* params) = 0; @@ -1697,10 +1760,15 @@ class GL_EXPORT GLApi { GLbitfield access) = 0; virtual void glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) = 0; virtual void glMatrixLoadIdentityEXTFn(GLenum matrixMode) = 0; + virtual void glObjectLabelKHRFn(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) = 0; virtual void glPauseTransformFeedbackFn(void) = 0; virtual void glPixelStoreiFn(GLenum pname, GLint param) = 0; virtual void glPointParameteriFn(GLenum pname, GLint param) = 0; virtual void glPolygonOffsetFn(GLfloat factor, GLfloat units) = 0; + virtual void glPopDebugGroupKHRFn(void) = 0; virtual void glPopGroupMarkerEXTFn(void) = 0; virtual void glProgramBinaryFn(GLuint program, GLenum binaryFormat, @@ -1709,6 +1777,10 @@ class GL_EXPORT GLApi { virtual void glProgramParameteriFn(GLuint program, GLenum pname, GLint value) = 0; + virtual void glPushDebugGroupKHRFn(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) = 0; virtual void glPushGroupMarkerEXTFn(GLsizei length, const char* marker) = 0; virtual void glQueryCounterFn(GLuint id, GLenum target) = 0; virtual void glReadBufferFn(GLenum src) = 0; @@ -2062,6 +2134,12 @@ class GL_EXPORT GLApi { #define glCreateProgram ::gfx::g_current_gl_context->glCreateProgramFn #define glCreateShader ::gfx::g_current_gl_context->glCreateShaderFn #define glCullFace ::gfx::g_current_gl_context->glCullFaceFn +#define glDebugMessageCallbackKHR \ + ::gfx::g_current_gl_context->glDebugMessageCallbackKHRFn +#define glDebugMessageControlKHR \ + ::gfx::g_current_gl_context->glDebugMessageControlKHRFn +#define glDebugMessageInsertKHR \ + ::gfx::g_current_gl_context->glDebugMessageInsertKHRFn #define glDeleteBuffersARB ::gfx::g_current_gl_context->glDeleteBuffersARBFn #define glDeleteFencesAPPLE ::gfx::g_current_gl_context->glDeleteFencesAPPLEFn #define glDeleteFencesNV ::gfx::g_current_gl_context->glDeleteFencesNVFn @@ -2152,6 +2230,8 @@ class GL_EXPORT GLApi { #define glGetBooleanv ::gfx::g_current_gl_context->glGetBooleanvFn #define glGetBufferParameteriv \ ::gfx::g_current_gl_context->glGetBufferParameterivFn +#define glGetDebugMessageLogKHR \ + ::gfx::g_current_gl_context->glGetDebugMessageLogKHRFn #define glGetError ::gfx::g_current_gl_context->glGetErrorFn #define glGetFenceivNV ::gfx::g_current_gl_context->glGetFenceivNVFn #define glGetFloatv ::gfx::g_current_gl_context->glGetFloatvFn @@ -2241,14 +2321,17 @@ class GL_EXPORT GLApi { #define glMatrixLoadfEXT ::gfx::g_current_gl_context->glMatrixLoadfEXTFn #define glMatrixLoadIdentityEXT \ ::gfx::g_current_gl_context->glMatrixLoadIdentityEXTFn +#define glObjectLabelKHR ::gfx::g_current_gl_context->glObjectLabelKHRFn #define glPauseTransformFeedback \ ::gfx::g_current_gl_context->glPauseTransformFeedbackFn #define glPixelStorei ::gfx::g_current_gl_context->glPixelStoreiFn #define glPointParameteri ::gfx::g_current_gl_context->glPointParameteriFn #define glPolygonOffset ::gfx::g_current_gl_context->glPolygonOffsetFn +#define glPopDebugGroupKHR ::gfx::g_current_gl_context->glPopDebugGroupKHRFn #define glPopGroupMarkerEXT ::gfx::g_current_gl_context->glPopGroupMarkerEXTFn #define glProgramBinary ::gfx::g_current_gl_context->glProgramBinaryFn #define glProgramParameteri ::gfx::g_current_gl_context->glProgramParameteriFn +#define glPushDebugGroupKHR ::gfx::g_current_gl_context->glPushDebugGroupKHRFn #define glPushGroupMarkerEXT ::gfx::g_current_gl_context->glPushGroupMarkerEXTFn #define glQueryCounter ::gfx::g_current_gl_context->glQueryCounterFn #define glReadBuffer ::gfx::g_current_gl_context->glReadBufferFn diff --git a/ui/gl/gl_bindings_autogen_glx.cc b/ui/gl/gl_bindings_autogen_glx.cc index ca36b7aa00c..da7aaac7165 100644 --- a/ui/gl/gl_bindings_autogen_glx.cc +++ b/ui/gl/gl_bindings_autogen_glx.cc @@ -237,8 +237,9 @@ Debug_glXChooseFBConfig(Display* dpy, return result; } -static XVisualInfo* GL_BINDING_CALL -Debug_glXChooseVisual(Display* dpy, int screen, int* attribList) { +static XVisualInfo* GL_BINDING_CALL Debug_glXChooseVisual(Display* dpy, + int screen, + int* attribList) { GL_SERVICE_LOG("glXChooseVisual" << "(" << static_cast(dpy) << ", " << screen << ", " << static_cast(attribList) << ")"); @@ -302,8 +303,9 @@ Debug_glXCreateContextAttribsARB(Display* dpy, return result; } -static GLXPixmap GL_BINDING_CALL -Debug_glXCreateGLXPixmap(Display* dpy, XVisualInfo* visual, Pixmap pixmap) { +static GLXPixmap GL_BINDING_CALL Debug_glXCreateGLXPixmap(Display* dpy, + XVisualInfo* visual, + Pixmap pixmap) { GL_SERVICE_LOG("glXCreateGLXPixmap" << "(" << static_cast(dpy) << ", " << static_cast(visual) << ", " << pixmap << ")"); @@ -370,47 +372,47 @@ static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy, return result; } -static void GL_BINDING_CALL -Debug_glXDestroyContext(Display* dpy, GLXContext ctx) { +static void GL_BINDING_CALL Debug_glXDestroyContext(Display* dpy, + GLXContext ctx) { GL_SERVICE_LOG("glXDestroyContext" << "(" << static_cast(dpy) << ", " << ctx << ")"); g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx); } -static void GL_BINDING_CALL -Debug_glXDestroyGLXPixmap(Display* dpy, GLXPixmap pixmap) { +static void GL_BINDING_CALL Debug_glXDestroyGLXPixmap(Display* dpy, + GLXPixmap pixmap) { GL_SERVICE_LOG("glXDestroyGLXPixmap" << "(" << static_cast(dpy) << ", " << pixmap << ")"); g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap); } -static void GL_BINDING_CALL -Debug_glXDestroyPbuffer(Display* dpy, GLXPbuffer pbuf) { +static void GL_BINDING_CALL Debug_glXDestroyPbuffer(Display* dpy, + GLXPbuffer pbuf) { GL_SERVICE_LOG("glXDestroyPbuffer" << "(" << static_cast(dpy) << ", " << pbuf << ")"); g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf); } -static void GL_BINDING_CALL -Debug_glXDestroyPixmap(Display* dpy, GLXPixmap pixmap) { +static void GL_BINDING_CALL Debug_glXDestroyPixmap(Display* dpy, + GLXPixmap pixmap) { GL_SERVICE_LOG("glXDestroyPixmap" << "(" << static_cast(dpy) << ", " << pixmap << ")"); g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap); } -static void GL_BINDING_CALL -Debug_glXDestroyWindow(Display* dpy, GLXWindow window) { +static void GL_BINDING_CALL Debug_glXDestroyWindow(Display* dpy, + GLXWindow window) { GL_SERVICE_LOG("glXDestroyWindow" << "(" << static_cast(dpy) << ", " << window << ")"); g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window); } -static const char* GL_BINDING_CALL -Debug_glXGetClientString(Display* dpy, int name) { +static const char* GL_BINDING_CALL Debug_glXGetClientString(Display* dpy, + int name) { GL_SERVICE_LOG("glXGetClientString" << "(" << static_cast(dpy) << ", " << name << ")"); @@ -419,8 +421,10 @@ Debug_glXGetClientString(Display* dpy, int name) { return result; } -static int GL_BINDING_CALL -Debug_glXGetConfig(Display* dpy, XVisualInfo* visual, int attrib, int* value) { +static int GL_BINDING_CALL Debug_glXGetConfig(Display* dpy, + XVisualInfo* visual, + int attrib, + int* value) { GL_SERVICE_LOG("glXGetConfig" << "(" << static_cast(dpy) << ", " << static_cast(visual) << ", " << attrib << ", " @@ -491,8 +495,9 @@ Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) { return result; } -static GLXFBConfig* GL_BINDING_CALL -Debug_glXGetFBConfigs(Display* dpy, int screen, int* nelements) { +static GLXFBConfig* GL_BINDING_CALL Debug_glXGetFBConfigs(Display* dpy, + int screen, + int* nelements) { GL_SERVICE_LOG("glXGetFBConfigs" << "(" << static_cast(dpy) << ", " << screen << ", " << static_cast(nelements) << ")"); @@ -573,8 +578,9 @@ static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy, return result; } -static int GL_BINDING_CALL -Debug_glXMakeCurrent(Display* dpy, GLXDrawable drawable, GLXContext ctx) { +static int GL_BINDING_CALL Debug_glXMakeCurrent(Display* dpy, + GLXDrawable drawable, + GLXContext ctx) { GL_SERVICE_LOG("glXMakeCurrent" << "(" << static_cast(dpy) << ", " << drawable << ", " << ctx << ")"); @@ -583,8 +589,10 @@ Debug_glXMakeCurrent(Display* dpy, GLXDrawable drawable, GLXContext ctx) { return result; } -static int GL_BINDING_CALL -Debug_glXQueryContext(Display* dpy, GLXContext ctx, int attribute, int* value) { +static int GL_BINDING_CALL Debug_glXQueryContext(Display* dpy, + GLXContext ctx, + int attribute, + int* value) { GL_SERVICE_LOG("glXQueryContext" << "(" << static_cast(dpy) << ", " << ctx << ", " << attribute << ", " << static_cast(value) @@ -606,8 +614,9 @@ static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy, g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value); } -static int GL_BINDING_CALL -Debug_glXQueryExtension(Display* dpy, int* errorb, int* event) { +static int GL_BINDING_CALL Debug_glXQueryExtension(Display* dpy, + int* errorb, + int* event) { GL_SERVICE_LOG("glXQueryExtension" << "(" << static_cast(dpy) << ", " << static_cast(errorb) << ", " @@ -617,8 +626,8 @@ Debug_glXQueryExtension(Display* dpy, int* errorb, int* event) { return result; } -static const char* GL_BINDING_CALL -Debug_glXQueryExtensionsString(Display* dpy, int screen) { +static const char* GL_BINDING_CALL Debug_glXQueryExtensionsString(Display* dpy, + int screen) { GL_SERVICE_LOG("glXQueryExtensionsString" << "(" << static_cast(dpy) << ", " << screen << ")"); @@ -628,8 +637,9 @@ Debug_glXQueryExtensionsString(Display* dpy, int screen) { return result; } -static const char* GL_BINDING_CALL -Debug_glXQueryServerString(Display* dpy, int screen, int name) { +static const char* GL_BINDING_CALL Debug_glXQueryServerString(Display* dpy, + int screen, + int name) { GL_SERVICE_LOG("glXQueryServerString" << "(" << static_cast(dpy) << ", " << screen << ", " << name << ")"); @@ -639,8 +649,9 @@ Debug_glXQueryServerString(Display* dpy, int screen, int name) { return result; } -static int GL_BINDING_CALL -Debug_glXQueryVersion(Display* dpy, int* maj, int* min) { +static int GL_BINDING_CALL Debug_glXQueryVersion(Display* dpy, + int* maj, + int* min) { GL_SERVICE_LOG("glXQueryVersion" << "(" << static_cast(dpy) << ", " << static_cast(maj) << ", " @@ -650,32 +661,35 @@ Debug_glXQueryVersion(Display* dpy, int* maj, int* min) { return result; } -static void GL_BINDING_CALL -Debug_glXReleaseTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer) { +static void GL_BINDING_CALL Debug_glXReleaseTexImageEXT(Display* dpy, + GLXDrawable drawable, + int buffer) { GL_SERVICE_LOG("glXReleaseTexImageEXT" << "(" << static_cast(dpy) << ", " << drawable << ", " << buffer << ")"); g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer); } -static void GL_BINDING_CALL -Debug_glXSelectEvent(Display* dpy, GLXDrawable drawable, unsigned long mask) { +static void GL_BINDING_CALL Debug_glXSelectEvent(Display* dpy, + GLXDrawable drawable, + unsigned long mask) { GL_SERVICE_LOG("glXSelectEvent" << "(" << static_cast(dpy) << ", " << drawable << ", " << mask << ")"); g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask); } -static void GL_BINDING_CALL -Debug_glXSwapBuffers(Display* dpy, GLXDrawable drawable) { +static void GL_BINDING_CALL Debug_glXSwapBuffers(Display* dpy, + GLXDrawable drawable) { GL_SERVICE_LOG("glXSwapBuffers" << "(" << static_cast(dpy) << ", " << drawable << ")"); g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable); } -static void GL_BINDING_CALL -Debug_glXSwapIntervalEXT(Display* dpy, GLXDrawable drawable, int interval) { +static void GL_BINDING_CALL Debug_glXSwapIntervalEXT(Display* dpy, + GLXDrawable drawable, + int interval) { GL_SERVICE_LOG("glXSwapIntervalEXT" << "(" << static_cast(dpy) << ", " << drawable << ", " << interval << ")"); @@ -688,8 +702,10 @@ static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) { g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval); } -static void GL_BINDING_CALL -Debug_glXUseXFont(Font font, int first, int count, int list) { +static void GL_BINDING_CALL Debug_glXUseXFont(Font font, + int first, + int count, + int list) { GL_SERVICE_LOG("glXUseXFont" << "(" << font << ", " << first << ", " << count << ", " << list << ")"); @@ -703,8 +719,9 @@ static void GL_BINDING_CALL Debug_glXWaitGL(void) { g_driver_glx.debug_fn.glXWaitGLFn(); } -static int GL_BINDING_CALL -Debug_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int* count) { +static int GL_BINDING_CALL Debug_glXWaitVideoSyncSGI(int divisor, + int remainder, + unsigned int* count) { GL_SERVICE_LOG("glXWaitVideoSyncSGI" << "(" << divisor << ", " << remainder << ", " << static_cast(count) << ")"); diff --git a/ui/gl/gl_bindings_autogen_mock.cc b/ui/gl/gl_bindings_autogen_mock.cc index b22484694f9..ef6e3bb53cd 100644 --- a/ui/gl/gl_bindings_autogen_mock.cc +++ b/ui/gl/gl_bindings_autogen_mock.cc @@ -26,26 +26,26 @@ void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) { interface_->ActiveTexture(texture); } -void GL_BINDING_CALL -MockGLInterface::Mock_glAttachShader(GLuint program, GLuint shader) { +void GL_BINDING_CALL MockGLInterface::Mock_glAttachShader(GLuint program, + GLuint shader) { MakeFunctionUnique("glAttachShader"); interface_->AttachShader(program, shader); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBeginQuery(GLenum target, GLuint id) { +void GL_BINDING_CALL MockGLInterface::Mock_glBeginQuery(GLenum target, + GLuint id) { MakeFunctionUnique("glBeginQuery"); interface_->BeginQuery(target, id); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBeginQueryARB(GLenum target, GLuint id) { +void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryARB(GLenum target, + GLuint id) { MakeFunctionUnique("glBeginQueryARB"); interface_->BeginQuery(target, id); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBeginQueryEXT(GLenum target, GLuint id) { +void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryEXT(GLenum target, + GLuint id) { MakeFunctionUnique("glBeginQueryEXT"); interface_->BeginQuery(target, id); } @@ -64,8 +64,8 @@ MockGLInterface::Mock_glBindAttribLocation(GLuint program, interface_->BindAttribLocation(program, index, name); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBindBuffer(GLenum target, GLuint buffer) { +void GL_BINDING_CALL MockGLInterface::Mock_glBindBuffer(GLenum target, + GLuint buffer) { MakeFunctionUnique("glBindBuffer"); interface_->BindBuffer(target, buffer); } @@ -128,14 +128,14 @@ MockGLInterface::Mock_glBindRenderbufferEXT(GLenum target, interface_->BindRenderbufferEXT(target, renderbuffer); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBindSampler(GLuint unit, GLuint sampler) { +void GL_BINDING_CALL MockGLInterface::Mock_glBindSampler(GLuint unit, + GLuint sampler) { MakeFunctionUnique("glBindSampler"); interface_->BindSampler(unit, sampler); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBindTexture(GLenum target, GLuint texture) { +void GL_BINDING_CALL MockGLInterface::Mock_glBindTexture(GLenum target, + GLuint texture) { MakeFunctionUnique("glBindTexture"); interface_->BindTexture(target, texture); } @@ -192,8 +192,8 @@ MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB, interface_->BlendEquationSeparate(modeRGB, modeAlpha); } -void GL_BINDING_CALL -MockGLInterface::Mock_glBlendFunc(GLenum sfactor, GLenum dfactor) { +void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor, + GLenum dfactor) { MakeFunctionUnique("glBlendFunc"); interface_->BlendFunc(sfactor, dfactor); } @@ -472,6 +472,36 @@ void GL_BINDING_CALL MockGLInterface::Mock_glCullFace(GLenum mode) { interface_->CullFace(mode); } +void GL_BINDING_CALL +MockGLInterface::Mock_glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, + const void* userparam) { + MakeFunctionUnique("glDebugMessageCallbackKHR"); + interface_->DebugMessageCallbackKHR(callback, userparam); +} + +void GL_BINDING_CALL +MockGLInterface::Mock_glDebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled) { + MakeFunctionUnique("glDebugMessageControlKHR"); + interface_->DebugMessageControlKHR(source, type, severity, count, ids, + enabled); +} + +void GL_BINDING_CALL +MockGLInterface::Mock_glDebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf) { + MakeFunctionUnique("glDebugMessageInsertKHR"); + interface_->DebugMessageInsertKHR(source, type, id, severity, length, buf); +} + void GL_BINDING_CALL MockGLInterface::Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers) { MakeFunctionUnique("glDeleteBuffers"); @@ -509,8 +539,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) { interface_->DeleteProgram(program); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDeleteQueries(GLsizei n, const GLuint* ids) { +void GL_BINDING_CALL MockGLInterface::Mock_glDeleteQueries(GLsizei n, + const GLuint* ids) { MakeFunctionUnique("glDeleteQueries"); interface_->DeleteQueries(n, ids); } @@ -598,20 +628,20 @@ void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) { interface_->DepthMask(flag); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDepthRange(GLclampd zNear, GLclampd zFar) { +void GL_BINDING_CALL MockGLInterface::Mock_glDepthRange(GLclampd zNear, + GLclampd zFar) { MakeFunctionUnique("glDepthRange"); interface_->DepthRange(zNear, zFar); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDepthRangef(GLclampf zNear, GLclampf zFar) { +void GL_BINDING_CALL MockGLInterface::Mock_glDepthRangef(GLclampf zNear, + GLclampf zFar) { MakeFunctionUnique("glDepthRangef"); interface_->DepthRangef(zNear, zFar); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDetachShader(GLuint program, GLuint shader) { +void GL_BINDING_CALL MockGLInterface::Mock_glDetachShader(GLuint program, + GLuint shader) { MakeFunctionUnique("glDetachShader"); interface_->DetachShader(program, shader); } @@ -635,8 +665,9 @@ MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target, interface_->DiscardFramebufferEXT(target, numAttachments, attachments); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDrawArrays(GLenum mode, GLint first, GLsizei count) { +void GL_BINDING_CALL MockGLInterface::Mock_glDrawArrays(GLenum mode, + GLint first, + GLsizei count) { MakeFunctionUnique("glDrawArrays"); interface_->DrawArrays(mode, first, count); } @@ -673,8 +704,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) { interface_->DrawBuffer(mode); } -void GL_BINDING_CALL -MockGLInterface::Mock_glDrawBuffers(GLsizei n, const GLenum* bufs) { +void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffers(GLsizei n, + const GLenum* bufs) { MakeFunctionUnique("glDrawBuffers"); interface_->DrawBuffersARB(n, bufs); } @@ -786,8 +817,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) { interface_->EndTransformFeedback(); } -GLsync GL_BINDING_CALL -MockGLInterface::Mock_glFenceSync(GLenum condition, GLbitfield flags) { +GLsync GL_BINDING_CALL MockGLInterface::Mock_glFenceSync(GLenum condition, + GLbitfield flags) { MakeFunctionUnique("glFenceSync"); return interface_->FenceSync(condition, flags); } @@ -902,20 +933,20 @@ void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) { interface_->FrontFace(mode); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenBuffers(GLsizei n, GLuint* buffers) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenBuffers(GLsizei n, + GLuint* buffers) { MakeFunctionUnique("glGenBuffers"); interface_->GenBuffersARB(n, buffers); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n, GLuint* fences) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n, + GLuint* fences) { MakeFunctionUnique("glGenFencesAPPLE"); interface_->GenFencesAPPLE(n, fences); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenFencesNV(GLsizei n, GLuint* fences) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesNV(GLsizei n, + GLuint* fences) { MakeFunctionUnique("glGenFencesNV"); interface_->GenFencesNV(n, fences); } @@ -932,20 +963,20 @@ MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) { interface_->GenFramebuffersEXT(n, framebuffers); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenQueries(GLsizei n, GLuint* ids) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenQueries(GLsizei n, + GLuint* ids) { MakeFunctionUnique("glGenQueries"); interface_->GenQueries(n, ids); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenQueriesARB(GLsizei n, GLuint* ids) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesARB(GLsizei n, + GLuint* ids) { MakeFunctionUnique("glGenQueriesARB"); interface_->GenQueries(n, ids); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenQueriesEXT(GLsizei n, GLuint* ids) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesEXT(GLsizei n, + GLuint* ids) { MakeFunctionUnique("glGenQueriesEXT"); interface_->GenQueries(n, ids); } @@ -962,14 +993,14 @@ MockGLInterface::Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) { interface_->GenRenderbuffersEXT(n, renderbuffers); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenSamplers(GLsizei n, GLuint* samplers) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenSamplers(GLsizei n, + GLuint* samplers) { MakeFunctionUnique("glGenSamplers"); interface_->GenSamplers(n, samplers); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenTextures(GLsizei n, GLuint* textures) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenTextures(GLsizei n, + GLuint* textures) { MakeFunctionUnique("glGenTextures"); interface_->GenTextures(n, textures); } @@ -980,8 +1011,8 @@ MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) { interface_->GenTransformFeedbacks(n, ids); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGenVertexArrays(GLsizei n, GLuint* arrays) { +void GL_BINDING_CALL MockGLInterface::Mock_glGenVertexArrays(GLsizei n, + GLuint* arrays) { MakeFunctionUnique("glGenVertexArrays"); interface_->GenVertexArraysOES(n, arrays); } @@ -1079,8 +1110,8 @@ MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) { return interface_->GetAttribLocation(program, name); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGetBooleanv(GLenum pname, GLboolean* params) { +void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname, + GLboolean* params) { MakeFunctionUnique("glGetBooleanv"); interface_->GetBooleanv(pname, params); } @@ -1093,6 +1124,20 @@ MockGLInterface::Mock_glGetBufferParameteriv(GLenum target, interface_->GetBufferParameteriv(target, pname, params); } +GLuint GL_BINDING_CALL +MockGLInterface::Mock_glGetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog) { + MakeFunctionUnique("glGetDebugMessageLogKHR"); + return interface_->GetDebugMessageLogKHR(count, bufSize, sources, types, ids, + severities, lengths, messageLog); +} + GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) { MakeFunctionUnique("glGetError"); return interface_->GetError(); @@ -1105,8 +1150,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence, interface_->GetFenceivNV(fence, pname, params); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGetFloatv(GLenum pname, GLfloat* params) { +void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname, + GLfloat* params) { MakeFunctionUnique("glGetFloatv"); interface_->GetFloatv(pname, params); } @@ -1165,8 +1210,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target, interface_->GetInteger64i_v(target, index, data); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGetInteger64v(GLenum pname, GLint64* params) { +void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname, + GLint64* params) { MakeFunctionUnique("glGetInteger64v"); interface_->GetInteger64v(pname, params); } @@ -1178,8 +1223,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target, interface_->GetIntegeri_v(target, index, data); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGetIntegerv(GLenum pname, GLint* params) { +void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname, + GLint* params) { MakeFunctionUnique("glGetIntegerv"); interface_->GetIntegerv(pname, params); } @@ -1317,8 +1362,9 @@ MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id, interface_->GetQueryObjectuiv(id, pname, params); } -void GL_BINDING_CALL -MockGLInterface::Mock_glGetQueryiv(GLenum target, GLenum pname, GLint* params) { +void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target, + GLenum pname, + GLint* params) { MakeFunctionUnique("glGetQueryiv"); interface_->GetQueryiv(target, pname, params); } @@ -1687,14 +1733,14 @@ void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) { interface_->LinkProgram(program); } -void* GL_BINDING_CALL -MockGLInterface::Mock_glMapBuffer(GLenum target, GLenum access) { +void* GL_BINDING_CALL MockGLInterface::Mock_glMapBuffer(GLenum target, + GLenum access) { MakeFunctionUnique("glMapBuffer"); return interface_->MapBuffer(target, access); } -void* GL_BINDING_CALL -MockGLInterface::Mock_glMapBufferOES(GLenum target, GLenum access) { +void* GL_BINDING_CALL MockGLInterface::Mock_glMapBufferOES(GLenum target, + GLenum access) { MakeFunctionUnique("glMapBufferOES"); return interface_->MapBuffer(target, access); } @@ -1723,35 +1769,49 @@ MockGLInterface::Mock_glMatrixLoadIdentityEXT(GLenum matrixMode) { interface_->MatrixLoadIdentityEXT(matrixMode); } -void GL_BINDING_CALL -MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) { +void GL_BINDING_CALL MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode, + const GLfloat* m) { MakeFunctionUnique("glMatrixLoadfEXT"); interface_->MatrixLoadfEXT(matrixMode, m); } +void GL_BINDING_CALL +MockGLInterface::Mock_glObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label) { + MakeFunctionUnique("glObjectLabelKHR"); + interface_->ObjectLabelKHR(identifier, name, length, label); +} + void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) { MakeFunctionUnique("glPauseTransformFeedback"); interface_->PauseTransformFeedback(); } -void GL_BINDING_CALL -MockGLInterface::Mock_glPixelStorei(GLenum pname, GLint param) { +void GL_BINDING_CALL MockGLInterface::Mock_glPixelStorei(GLenum pname, + GLint param) { MakeFunctionUnique("glPixelStorei"); interface_->PixelStorei(pname, param); } -void GL_BINDING_CALL -MockGLInterface::Mock_glPointParameteri(GLenum pname, GLint param) { +void GL_BINDING_CALL MockGLInterface::Mock_glPointParameteri(GLenum pname, + GLint param) { MakeFunctionUnique("glPointParameteri"); interface_->PointParameteri(pname, param); } -void GL_BINDING_CALL -MockGLInterface::Mock_glPolygonOffset(GLfloat factor, GLfloat units) { +void GL_BINDING_CALL MockGLInterface::Mock_glPolygonOffset(GLfloat factor, + GLfloat units) { MakeFunctionUnique("glPolygonOffset"); interface_->PolygonOffset(factor, units); } +void GL_BINDING_CALL MockGLInterface::Mock_glPopDebugGroupKHR(void) { + MakeFunctionUnique("glPopDebugGroupKHR"); + interface_->PopDebugGroupKHR(); +} + void GL_BINDING_CALL MockGLInterface::Mock_glPopGroupMarkerEXT(void) { MakeFunctionUnique("glPopGroupMarkerEXT"); interface_->PopGroupMarkerEXT(); @@ -1781,20 +1841,29 @@ void GL_BINDING_CALL MockGLInterface::Mock_glProgramParameteri(GLuint program, interface_->ProgramParameteri(program, pname, value); } +void GL_BINDING_CALL +MockGLInterface::Mock_glPushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message) { + MakeFunctionUnique("glPushDebugGroupKHR"); + interface_->PushDebugGroupKHR(source, id, length, message); +} + void GL_BINDING_CALL MockGLInterface::Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker) { MakeFunctionUnique("glPushGroupMarkerEXT"); interface_->PushGroupMarkerEXT(length, marker); } -void GL_BINDING_CALL -MockGLInterface::Mock_glQueryCounter(GLuint id, GLenum target) { +void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounter(GLuint id, + GLenum target) { MakeFunctionUnique("glQueryCounter"); interface_->QueryCounter(id, target); } -void GL_BINDING_CALL -MockGLInterface::Mock_glQueryCounterEXT(GLuint id, GLenum target) { +void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounterEXT(GLuint id, + GLenum target) { MakeFunctionUnique("glQueryCounterEXT"); interface_->QueryCounter(id, target); } @@ -1906,8 +1975,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glResumeTransformFeedback(void) { interface_->ResumeTransformFeedback(); } -void GL_BINDING_CALL -MockGLInterface::Mock_glSampleCoverage(GLclampf value, GLboolean invert) { +void GL_BINDING_CALL MockGLInterface::Mock_glSampleCoverage(GLclampf value, + GLboolean invert) { MakeFunctionUnique("glSampleCoverage"); interface_->SampleCoverage(value, invert); } @@ -1955,8 +2024,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceAPPLE(GLuint fence) { interface_->SetFenceAPPLE(fence); } -void GL_BINDING_CALL -MockGLInterface::Mock_glSetFenceNV(GLuint fence, GLenum condition) { +void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceNV(GLuint fence, + GLenum condition) { MakeFunctionUnique("glSetFenceNV"); interface_->SetFenceNV(fence, condition); } @@ -1979,8 +2048,9 @@ MockGLInterface::Mock_glShaderSource(GLuint shader, interface_->ShaderSource(shader, count, str, length); } -void GL_BINDING_CALL -MockGLInterface::Mock_glStencilFunc(GLenum func, GLint ref, GLuint mask) { +void GL_BINDING_CALL MockGLInterface::Mock_glStencilFunc(GLenum func, + GLint ref, + GLuint mask) { MakeFunctionUnique("glStencilFunc"); interface_->StencilFunc(func, ref, mask); } @@ -1998,14 +2068,15 @@ void GL_BINDING_CALL MockGLInterface::Mock_glStencilMask(GLuint mask) { interface_->StencilMask(mask); } -void GL_BINDING_CALL -MockGLInterface::Mock_glStencilMaskSeparate(GLenum face, GLuint mask) { +void GL_BINDING_CALL MockGLInterface::Mock_glStencilMaskSeparate(GLenum face, + GLuint mask) { MakeFunctionUnique("glStencilMaskSeparate"); interface_->StencilMaskSeparate(face, mask); } -void GL_BINDING_CALL -MockGLInterface::Mock_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { +void GL_BINDING_CALL MockGLInterface::Mock_glStencilOp(GLenum fail, + GLenum zfail, + GLenum zpass) { MakeFunctionUnique("glStencilOp"); interface_->StencilOp(fail, zfail, zpass); } @@ -2140,8 +2211,8 @@ MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program, interface_->TransformFeedbackVaryings(program, count, varyings, bufferMode); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform1f(GLint location, GLfloat x) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform1f(GLint location, + GLfloat x) { MakeFunctionUnique("glUniform1f"); interface_->Uniform1f(location, x); } @@ -2153,8 +2224,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1fv(GLint location, interface_->Uniform1fv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform1i(GLint location, GLint x) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform1i(GLint location, + GLint x) { MakeFunctionUnique("glUniform1i"); interface_->Uniform1i(location, x); } @@ -2166,8 +2237,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1iv(GLint location, interface_->Uniform1iv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform1ui(GLint location, GLuint v0) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform1ui(GLint location, + GLuint v0) { MakeFunctionUnique("glUniform1ui"); interface_->Uniform1ui(location, v0); } @@ -2179,8 +2250,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1uiv(GLint location, interface_->Uniform1uiv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform2f(GLint location, GLfloat x, GLfloat y) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform2f(GLint location, + GLfloat x, + GLfloat y) { MakeFunctionUnique("glUniform2f"); interface_->Uniform2f(location, x, y); } @@ -2192,8 +2264,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform2fv(GLint location, interface_->Uniform2fv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform2i(GLint location, GLint x, GLint y) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform2i(GLint location, + GLint x, + GLint y) { MakeFunctionUnique("glUniform2i"); interface_->Uniform2i(location, x, y); } @@ -2205,8 +2278,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform2iv(GLint location, interface_->Uniform2iv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform2ui(GLint location, GLuint v0, GLuint v1) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform2ui(GLint location, + GLuint v0, + GLuint v1) { MakeFunctionUnique("glUniform2ui"); interface_->Uniform2ui(location, v0, v1); } @@ -2233,8 +2307,10 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform3fv(GLint location, interface_->Uniform3fv(location, count, v); } -void GL_BINDING_CALL -MockGLInterface::Mock_glUniform3i(GLint location, GLint x, GLint y, GLint z) { +void GL_BINDING_CALL MockGLInterface::Mock_glUniform3i(GLint location, + GLint x, + GLint y, + GLint z) { MakeFunctionUnique("glUniform3i"); interface_->Uniform3i(location, x, y, z); } @@ -2420,8 +2496,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glValidateProgram(GLuint program) { interface_->ValidateProgram(program); } -void GL_BINDING_CALL -MockGLInterface::Mock_glVertexAttrib1f(GLuint indx, GLfloat x) { +void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib1f(GLuint indx, + GLfloat x) { MakeFunctionUnique("glVertexAttrib1f"); interface_->VertexAttrib1f(indx, x); } @@ -2432,8 +2508,9 @@ MockGLInterface::Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values) { interface_->VertexAttrib1fv(indx, values); } -void GL_BINDING_CALL -MockGLInterface::Mock_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { +void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib2f(GLuint indx, + GLfloat x, + GLfloat y) { MakeFunctionUnique("glVertexAttrib2f"); interface_->VertexAttrib2f(indx, x, y); } @@ -2678,6 +2755,12 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast(Mock_glCreateShader); if (strcmp(name, "glCullFace") == 0) return reinterpret_cast(Mock_glCullFace); + if (strcmp(name, "glDebugMessageCallbackKHR") == 0) + return reinterpret_cast(Mock_glDebugMessageCallbackKHR); + if (strcmp(name, "glDebugMessageControlKHR") == 0) + return reinterpret_cast(Mock_glDebugMessageControlKHR); + if (strcmp(name, "glDebugMessageInsertKHR") == 0) + return reinterpret_cast(Mock_glDebugMessageInsertKHR); if (strcmp(name, "glDeleteBuffers") == 0) return reinterpret_cast(Mock_glDeleteBuffers); if (strcmp(name, "glDeleteFencesAPPLE") == 0) @@ -2856,6 +2939,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast(Mock_glGetBooleanv); if (strcmp(name, "glGetBufferParameteriv") == 0) return reinterpret_cast(Mock_glGetBufferParameteriv); + if (strcmp(name, "glGetDebugMessageLogKHR") == 0) + return reinterpret_cast(Mock_glGetDebugMessageLogKHR); if (strcmp(name, "glGetError") == 0) return reinterpret_cast(Mock_glGetError); if (strcmp(name, "glGetFenceivNV") == 0) @@ -3037,6 +3122,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast(Mock_glMatrixLoadIdentityEXT); if (strcmp(name, "glMatrixLoadfEXT") == 0) return reinterpret_cast(Mock_glMatrixLoadfEXT); + if (strcmp(name, "glObjectLabelKHR") == 0) + return reinterpret_cast(Mock_glObjectLabelKHR); if (strcmp(name, "glPauseTransformFeedback") == 0) return reinterpret_cast(Mock_glPauseTransformFeedback); if (strcmp(name, "glPixelStorei") == 0) @@ -3045,6 +3132,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast(Mock_glPointParameteri); if (strcmp(name, "glPolygonOffset") == 0) return reinterpret_cast(Mock_glPolygonOffset); + if (strcmp(name, "glPopDebugGroupKHR") == 0) + return reinterpret_cast(Mock_glPopDebugGroupKHR); if (strcmp(name, "glPopGroupMarkerEXT") == 0) return reinterpret_cast(Mock_glPopGroupMarkerEXT); if (strcmp(name, "glProgramBinary") == 0) @@ -3053,6 +3142,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) { return reinterpret_cast(Mock_glProgramBinaryOES); if (strcmp(name, "glProgramParameteri") == 0) return reinterpret_cast(Mock_glProgramParameteri); + if (strcmp(name, "glPushDebugGroupKHR") == 0) + return reinterpret_cast(Mock_glPushDebugGroupKHR); if (strcmp(name, "glPushGroupMarkerEXT") == 0) return reinterpret_cast(Mock_glPushGroupMarkerEXT); if (strcmp(name, "glQueryCounter") == 0) diff --git a/ui/gl/gl_bindings_autogen_mock.h b/ui/gl/gl_bindings_autogen_mock.h index 9e2770ca08c..fbe3273a991 100644 --- a/ui/gl/gl_bindings_autogen_mock.h +++ b/ui/gl/gl_bindings_autogen_mock.h @@ -14,11 +14,13 @@ static void GL_BINDING_CALL Mock_glBeginQuery(GLenum target, GLuint id); static void GL_BINDING_CALL Mock_glBeginQueryARB(GLenum target, GLuint id); static void GL_BINDING_CALL Mock_glBeginQueryEXT(GLenum target, GLuint id); static void GL_BINDING_CALL Mock_glBeginTransformFeedback(GLenum primitiveMode); -static void GL_BINDING_CALL -Mock_glBindAttribLocation(GLuint program, GLuint index, const char* name); +static void GL_BINDING_CALL Mock_glBindAttribLocation(GLuint program, + GLuint index, + const char* name); static void GL_BINDING_CALL Mock_glBindBuffer(GLenum target, GLuint buffer); -static void GL_BINDING_CALL -Mock_glBindBufferBase(GLenum target, GLuint index, GLuint buffer); +static void GL_BINDING_CALL Mock_glBindBufferBase(GLenum target, + GLuint index, + GLuint buffer); static void GL_BINDING_CALL Mock_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, @@ -32,28 +34,30 @@ Mock_glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const char* name); -static void GL_BINDING_CALL -Mock_glBindFramebuffer(GLenum target, GLuint framebuffer); -static void GL_BINDING_CALL -Mock_glBindFramebufferEXT(GLenum target, GLuint framebuffer); -static void GL_BINDING_CALL -Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer); -static void GL_BINDING_CALL -Mock_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer); +static void GL_BINDING_CALL Mock_glBindFramebuffer(GLenum target, + GLuint framebuffer); +static void GL_BINDING_CALL Mock_glBindFramebufferEXT(GLenum target, + GLuint framebuffer); +static void GL_BINDING_CALL Mock_glBindRenderbuffer(GLenum target, + GLuint renderbuffer); +static void GL_BINDING_CALL Mock_glBindRenderbufferEXT(GLenum target, + GLuint renderbuffer); static void GL_BINDING_CALL Mock_glBindSampler(GLuint unit, GLuint sampler); static void GL_BINDING_CALL Mock_glBindTexture(GLenum target, GLuint texture); -static void GL_BINDING_CALL -Mock_glBindTransformFeedback(GLenum target, GLuint id); +static void GL_BINDING_CALL Mock_glBindTransformFeedback(GLenum target, + GLuint id); static void GL_BINDING_CALL Mock_glBindVertexArray(GLuint array); static void GL_BINDING_CALL Mock_glBindVertexArrayAPPLE(GLuint array); static void GL_BINDING_CALL Mock_glBindVertexArrayOES(GLuint array); static void GL_BINDING_CALL Mock_glBlendBarrierKHR(void); static void GL_BINDING_CALL Mock_glBlendBarrierNV(void); -static void GL_BINDING_CALL -Mock_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +static void GL_BINDING_CALL Mock_glBlendColor(GLclampf red, + GLclampf green, + GLclampf blue, + GLclampf alpha); static void GL_BINDING_CALL Mock_glBlendEquation(GLenum mode); -static void GL_BINDING_CALL -Mock_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +static void GL_BINDING_CALL Mock_glBlendEquationSeparate(GLenum modeRGB, + GLenum modeAlpha); static void GL_BINDING_CALL Mock_glBlendFunc(GLenum sfactor, GLenum dfactor); static void GL_BINDING_CALL Mock_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, @@ -104,19 +108,25 @@ static void GL_BINDING_CALL Mock_glClearBufferfi(GLenum buffer, GLint drawbuffer, const GLfloat depth, GLint stencil); -static void GL_BINDING_CALL -Mock_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value); -static void GL_BINDING_CALL -Mock_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value); -static void GL_BINDING_CALL -Mock_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value); -static void GL_BINDING_CALL -Mock_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +static void GL_BINDING_CALL Mock_glClearBufferfv(GLenum buffer, + GLint drawbuffer, + const GLfloat* value); +static void GL_BINDING_CALL Mock_glClearBufferiv(GLenum buffer, + GLint drawbuffer, + const GLint* value); +static void GL_BINDING_CALL Mock_glClearBufferuiv(GLenum buffer, + GLint drawbuffer, + const GLuint* value); +static void GL_BINDING_CALL Mock_glClearColor(GLclampf red, + GLclampf green, + GLclampf blue, + GLclampf alpha); static void GL_BINDING_CALL Mock_glClearDepth(GLclampd depth); static void GL_BINDING_CALL Mock_glClearDepthf(GLclampf depth); static void GL_BINDING_CALL Mock_glClearStencil(GLint s); -static GLenum GL_BINDING_CALL -Mock_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +static GLenum GL_BINDING_CALL Mock_glClientWaitSync(GLsync sync, + GLbitfield flags, + GLuint64 timeout); static void GL_BINDING_CALL Mock_glColorMask(GLboolean red, GLboolean green, GLboolean blue, @@ -182,39 +192,53 @@ static GLuint GL_BINDING_CALL Mock_glCreateProgram(void); static GLuint GL_BINDING_CALL Mock_glCreateShader(GLenum type); static void GL_BINDING_CALL Mock_glCullFace(GLenum mode); static void GL_BINDING_CALL -Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers); -static void GL_BINDING_CALL -Mock_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences); -static void GL_BINDING_CALL -Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences); +Mock_glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void* userparam); +static void GL_BINDING_CALL Mock_glDebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled); +static void GL_BINDING_CALL Mock_glDebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf); +static void GL_BINDING_CALL Mock_glDeleteBuffers(GLsizei n, + const GLuint* buffers); +static void GL_BINDING_CALL Mock_glDeleteFencesAPPLE(GLsizei n, + const GLuint* fences); +static void GL_BINDING_CALL Mock_glDeleteFencesNV(GLsizei n, + const GLuint* fences); static void GL_BINDING_CALL Mock_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers); static void GL_BINDING_CALL Mock_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers); static void GL_BINDING_CALL Mock_glDeleteProgram(GLuint program); static void GL_BINDING_CALL Mock_glDeleteQueries(GLsizei n, const GLuint* ids); -static void GL_BINDING_CALL -Mock_glDeleteQueriesARB(GLsizei n, const GLuint* ids); -static void GL_BINDING_CALL -Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids); +static void GL_BINDING_CALL Mock_glDeleteQueriesARB(GLsizei n, + const GLuint* ids); +static void GL_BINDING_CALL Mock_glDeleteQueriesEXT(GLsizei n, + const GLuint* ids); static void GL_BINDING_CALL Mock_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers); static void GL_BINDING_CALL Mock_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers); -static void GL_BINDING_CALL -Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers); +static void GL_BINDING_CALL Mock_glDeleteSamplers(GLsizei n, + const GLuint* samplers); static void GL_BINDING_CALL Mock_glDeleteShader(GLuint shader); static void GL_BINDING_CALL Mock_glDeleteSync(GLsync sync); -static void GL_BINDING_CALL -Mock_glDeleteTextures(GLsizei n, const GLuint* textures); -static void GL_BINDING_CALL -Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids); -static void GL_BINDING_CALL -Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays); +static void GL_BINDING_CALL Mock_glDeleteTextures(GLsizei n, + const GLuint* textures); +static void GL_BINDING_CALL Mock_glDeleteTransformFeedbacks(GLsizei n, + const GLuint* ids); +static void GL_BINDING_CALL Mock_glDeleteVertexArrays(GLsizei n, + const GLuint* arrays); static void GL_BINDING_CALL Mock_glDeleteVertexArraysAPPLE(GLsizei n, const GLuint* arrays); -static void GL_BINDING_CALL -Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays); +static void GL_BINDING_CALL Mock_glDeleteVertexArraysOES(GLsizei n, + const GLuint* arrays); static void GL_BINDING_CALL Mock_glDepthFunc(GLenum func); static void GL_BINDING_CALL Mock_glDepthMask(GLboolean flag); static void GL_BINDING_CALL Mock_glDepthRange(GLclampd zNear, GLclampd zFar); @@ -226,8 +250,9 @@ static void GL_BINDING_CALL Mock_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments); -static void GL_BINDING_CALL -Mock_glDrawArrays(GLenum mode, GLint first, GLsizei count); +static void GL_BINDING_CALL Mock_glDrawArrays(GLenum mode, + GLint first, + GLsizei count); static void GL_BINDING_CALL Mock_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, @@ -242,10 +267,10 @@ static void GL_BINDING_CALL Mock_glDrawArraysInstancedARB(GLenum mode, GLsizei primcount); static void GL_BINDING_CALL Mock_glDrawBuffer(GLenum mode); static void GL_BINDING_CALL Mock_glDrawBuffers(GLsizei n, const GLenum* bufs); -static void GL_BINDING_CALL -Mock_glDrawBuffersARB(GLsizei n, const GLenum* bufs); -static void GL_BINDING_CALL -Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs); +static void GL_BINDING_CALL Mock_glDrawBuffersARB(GLsizei n, + const GLenum* bufs); +static void GL_BINDING_CALL Mock_glDrawBuffersEXT(GLsizei n, + const GLenum* bufs); static void GL_BINDING_CALL Mock_glDrawElements(GLenum mode, GLsizei count, GLenum type, @@ -282,8 +307,8 @@ static void GL_BINDING_CALL Mock_glEndQuery(GLenum target); static void GL_BINDING_CALL Mock_glEndQueryARB(GLenum target); static void GL_BINDING_CALL Mock_glEndQueryEXT(GLenum target); static void GL_BINDING_CALL Mock_glEndTransformFeedback(void); -static GLsync GL_BINDING_CALL -Mock_glFenceSync(GLenum condition, GLbitfield flags); +static GLsync GL_BINDING_CALL Mock_glFenceSync(GLenum condition, + GLbitfield flags); static void GL_BINDING_CALL Mock_glFinish(void); static void GL_BINDING_CALL Mock_glFinishFenceAPPLE(GLuint fence); static void GL_BINDING_CALL Mock_glFinishFenceNV(GLuint fence); @@ -334,26 +359,26 @@ static void GL_BINDING_CALL Mock_glFrontFace(GLenum mode); static void GL_BINDING_CALL Mock_glGenBuffers(GLsizei n, GLuint* buffers); static void GL_BINDING_CALL Mock_glGenFencesAPPLE(GLsizei n, GLuint* fences); static void GL_BINDING_CALL Mock_glGenFencesNV(GLsizei n, GLuint* fences); -static void GL_BINDING_CALL -Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers); -static void GL_BINDING_CALL -Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers); +static void GL_BINDING_CALL Mock_glGenFramebuffers(GLsizei n, + GLuint* framebuffers); +static void GL_BINDING_CALL Mock_glGenFramebuffersEXT(GLsizei n, + GLuint* framebuffers); static void GL_BINDING_CALL Mock_glGenQueries(GLsizei n, GLuint* ids); static void GL_BINDING_CALL Mock_glGenQueriesARB(GLsizei n, GLuint* ids); static void GL_BINDING_CALL Mock_glGenQueriesEXT(GLsizei n, GLuint* ids); -static void GL_BINDING_CALL -Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers); -static void GL_BINDING_CALL -Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers); +static void GL_BINDING_CALL Mock_glGenRenderbuffers(GLsizei n, + GLuint* renderbuffers); +static void GL_BINDING_CALL Mock_glGenRenderbuffersEXT(GLsizei n, + GLuint* renderbuffers); static void GL_BINDING_CALL Mock_glGenSamplers(GLsizei n, GLuint* samplers); static void GL_BINDING_CALL Mock_glGenTextures(GLsizei n, GLuint* textures); -static void GL_BINDING_CALL -Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids); +static void GL_BINDING_CALL Mock_glGenTransformFeedbacks(GLsizei n, + GLuint* ids); static void GL_BINDING_CALL Mock_glGenVertexArrays(GLsizei n, GLuint* arrays); -static void GL_BINDING_CALL -Mock_glGenVertexArraysAPPLE(GLsizei n, GLuint* arrays); -static void GL_BINDING_CALL -Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays); +static void GL_BINDING_CALL Mock_glGenVertexArraysAPPLE(GLsizei n, + GLuint* arrays); +static void GL_BINDING_CALL Mock_glGenVertexArraysOES(GLsizei n, + GLuint* arrays); static void GL_BINDING_CALL Mock_glGenerateMipmap(GLenum target); static void GL_BINDING_CALL Mock_glGenerateMipmapEXT(GLenum target); static void GL_BINDING_CALL Mock_glGetActiveAttrib(GLuint program, @@ -391,17 +416,27 @@ static void GL_BINDING_CALL Mock_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); -static GLint GL_BINDING_CALL -Mock_glGetAttribLocation(GLuint program, const char* name); +static GLint GL_BINDING_CALL Mock_glGetAttribLocation(GLuint program, + const char* name); static void GL_BINDING_CALL Mock_glGetBooleanv(GLenum pname, GLboolean* params); -static void GL_BINDING_CALL -Mock_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetBufferParameteriv(GLenum target, + GLenum pname, + GLint* params); +static GLuint GL_BINDING_CALL Mock_glGetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog); static GLenum GL_BINDING_CALL Mock_glGetError(void); -static void GL_BINDING_CALL -Mock_glGetFenceivNV(GLuint fence, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetFenceivNV(GLuint fence, + GLenum pname, + GLint* params); static void GL_BINDING_CALL Mock_glGetFloatv(GLenum pname, GLfloat* params); -static GLint GL_BINDING_CALL -Mock_glGetFragDataLocation(GLuint program, const char* name); +static GLint GL_BINDING_CALL Mock_glGetFragDataLocation(GLuint program, + const char* name); static void GL_BINDING_CALL Mock_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, @@ -416,11 +451,13 @@ static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatus(void); static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusARB(void); static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusEXT(void); static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusKHR(void); -static void GL_BINDING_CALL -Mock_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data); +static void GL_BINDING_CALL Mock_glGetInteger64i_v(GLenum target, + GLuint index, + GLint64* data); static void GL_BINDING_CALL Mock_glGetInteger64v(GLenum pname, GLint64* params); -static void GL_BINDING_CALL -Mock_glGetIntegeri_v(GLenum target, GLuint index, GLint* data); +static void GL_BINDING_CALL Mock_glGetIntegeri_v(GLenum target, + GLuint index, + GLint* data); static void GL_BINDING_CALL Mock_glGetIntegerv(GLenum pname, GLint* params); static void GL_BINDING_CALL Mock_glGetInternalformativ(GLenum target, GLenum internalformat, @@ -445,43 +482,60 @@ static GLint GL_BINDING_CALL Mock_glGetProgramResourceLocation(GLuint program, GLenum programInterface, const char* name); -static void GL_BINDING_CALL -Mock_glGetProgramiv(GLuint program, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectiv(GLuint id, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint* params); -static void GL_BINDING_CALL -Mock_glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params); -static void GL_BINDING_CALL -Mock_glGetQueryiv(GLenum target, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryivARB(GLenum target, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetQueryivEXT(GLenum target, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetProgramiv(GLuint program, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjecti64v(GLuint id, + GLenum pname, + GLint64* params); +static void GL_BINDING_CALL Mock_glGetQueryObjecti64vEXT(GLuint id, + GLenum pname, + GLint64* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectiv(GLuint id, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectivARB(GLuint id, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectivEXT(GLuint id, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectui64v(GLuint id, + GLenum pname, + GLuint64* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectui64vEXT(GLuint id, + GLenum pname, + GLuint64* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectuiv(GLuint id, + GLenum pname, + GLuint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectuivARB(GLuint id, + GLenum pname, + GLuint* params); +static void GL_BINDING_CALL Mock_glGetQueryObjectuivEXT(GLuint id, + GLenum pname, + GLuint* params); +static void GL_BINDING_CALL Mock_glGetQueryiv(GLenum target, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryivARB(GLenum target, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetQueryivEXT(GLenum target, + GLenum pname, + GLint* params); +static void GL_BINDING_CALL Mock_glGetRenderbufferParameteriv(GLenum target, + GLenum pname, + GLint* params); static void GL_BINDING_CALL Mock_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params); -static void GL_BINDING_CALL -Mock_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetSamplerParameterfv(GLuint sampler, + GLenum pname, + GLfloat* params); +static void GL_BINDING_CALL Mock_glGetSamplerParameteriv(GLuint sampler, + GLenum pname, + GLint* params); static void GL_BINDING_CALL Mock_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, @@ -495,11 +549,12 @@ static void GL_BINDING_CALL Mock_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source); -static void GL_BINDING_CALL -Mock_glGetShaderiv(GLuint shader, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetShaderiv(GLuint shader, + GLenum pname, + GLint* params); static const GLubyte* GL_BINDING_CALL Mock_glGetString(GLenum name); -static const GLubyte* GL_BINDING_CALL -Mock_glGetStringi(GLenum name, GLuint index); +static const GLubyte* GL_BINDING_CALL Mock_glGetStringi(GLenum name, + GLuint index); static void GL_BINDING_CALL Mock_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, @@ -513,10 +568,12 @@ static void GL_BINDING_CALL Mock_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params); -static void GL_BINDING_CALL -Mock_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); -static void GL_BINDING_CALL -Mock_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); +static void GL_BINDING_CALL Mock_glGetTexParameterfv(GLenum target, + GLenum pname, + GLfloat* params); +static void GL_BINDING_CALL Mock_glGetTexParameteriv(GLenum target, + GLenum pname, + GLint* params); static void GL_BINDING_CALL Mock_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, @@ -536,21 +593,26 @@ Mock_glGetUniformIndices(GLuint program, GLsizei uniformCount, const char* const* uniformNames, GLuint* uniformIndices); -static GLint GL_BINDING_CALL -Mock_glGetUniformLocation(GLuint program, const char* name); -static void GL_BINDING_CALL -Mock_glGetUniformfv(GLuint program, GLint location, GLfloat* params); -static void GL_BINDING_CALL -Mock_glGetUniformiv(GLuint program, GLint location, GLint* params); -static void GL_BINDING_CALL -Mock_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer); -static void GL_BINDING_CALL -Mock_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); -static void GL_BINDING_CALL -Mock_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); +static GLint GL_BINDING_CALL Mock_glGetUniformLocation(GLuint program, + const char* name); +static void GL_BINDING_CALL Mock_glGetUniformfv(GLuint program, + GLint location, + GLfloat* params); +static void GL_BINDING_CALL Mock_glGetUniformiv(GLuint program, + GLint location, + GLint* params); +static void GL_BINDING_CALL Mock_glGetVertexAttribPointerv(GLuint index, + GLenum pname, + void** pointer); +static void GL_BINDING_CALL Mock_glGetVertexAttribfv(GLuint index, + GLenum pname, + GLfloat* params); +static void GL_BINDING_CALL Mock_glGetVertexAttribiv(GLuint index, + GLenum pname, + GLint* params); static void GL_BINDING_CALL Mock_glHint(GLenum target, GLenum mode); -static void GL_BINDING_CALL -Mock_glInsertEventMarkerEXT(GLsizei length, const char* marker); +static void GL_BINDING_CALL Mock_glInsertEventMarkerEXT(GLsizei length, + const char* marker); static void GL_BINDING_CALL Mock_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, @@ -596,12 +658,17 @@ static void* GL_BINDING_CALL Mock_glMapBufferRangeEXT(GLenum target, GLsizeiptr length, GLbitfield access); static void GL_BINDING_CALL Mock_glMatrixLoadIdentityEXT(GLenum matrixMode); -static void GL_BINDING_CALL -Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m); +static void GL_BINDING_CALL Mock_glMatrixLoadfEXT(GLenum matrixMode, + const GLfloat* m); +static void GL_BINDING_CALL Mock_glObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar* label); static void GL_BINDING_CALL Mock_glPauseTransformFeedback(void); static void GL_BINDING_CALL Mock_glPixelStorei(GLenum pname, GLint param); static void GL_BINDING_CALL Mock_glPointParameteri(GLenum pname, GLint param); static void GL_BINDING_CALL Mock_glPolygonOffset(GLfloat factor, GLfloat units); +static void GL_BINDING_CALL Mock_glPopDebugGroupKHR(void); static void GL_BINDING_CALL Mock_glPopGroupMarkerEXT(void); static void GL_BINDING_CALL Mock_glProgramBinary(GLuint program, GLenum binaryFormat, @@ -611,10 +678,15 @@ static void GL_BINDING_CALL Mock_glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); -static void GL_BINDING_CALL -Mock_glProgramParameteri(GLuint program, GLenum pname, GLint value); -static void GL_BINDING_CALL -Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker); +static void GL_BINDING_CALL Mock_glProgramParameteri(GLuint program, + GLenum pname, + GLint value); +static void GL_BINDING_CALL Mock_glPushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar* message); +static void GL_BINDING_CALL Mock_glPushGroupMarkerEXT(GLsizei length, + const char* marker); static void GL_BINDING_CALL Mock_glQueryCounter(GLuint id, GLenum target); static void GL_BINDING_CALL Mock_glQueryCounterEXT(GLuint id, GLenum target); static void GL_BINDING_CALL Mock_glReadBuffer(GLenum src); @@ -666,18 +738,24 @@ Mock_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei height); static void GL_BINDING_CALL Mock_glResolveMultisampleFramebufferAPPLE(void); static void GL_BINDING_CALL Mock_glResumeTransformFeedback(void); -static void GL_BINDING_CALL -Mock_glSampleCoverage(GLclampf value, GLboolean invert); -static void GL_BINDING_CALL -Mock_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param); -static void GL_BINDING_CALL -Mock_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* params); -static void GL_BINDING_CALL -Mock_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param); -static void GL_BINDING_CALL -Mock_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* params); -static void GL_BINDING_CALL -Mock_glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +static void GL_BINDING_CALL Mock_glSampleCoverage(GLclampf value, + GLboolean invert); +static void GL_BINDING_CALL Mock_glSamplerParameterf(GLuint sampler, + GLenum pname, + GLfloat param); +static void GL_BINDING_CALL Mock_glSamplerParameterfv(GLuint sampler, + GLenum pname, + const GLfloat* params); +static void GL_BINDING_CALL Mock_glSamplerParameteri(GLuint sampler, + GLenum pname, + GLint param); +static void GL_BINDING_CALL Mock_glSamplerParameteriv(GLuint sampler, + GLenum pname, + const GLint* params); +static void GL_BINDING_CALL Mock_glScissor(GLint x, + GLint y, + GLsizei width, + GLsizei height); static void GL_BINDING_CALL Mock_glSetFenceAPPLE(GLuint fence); static void GL_BINDING_CALL Mock_glSetFenceNV(GLuint fence, GLenum condition); static void GL_BINDING_CALL Mock_glShaderBinary(GLsizei n, @@ -689,17 +767,23 @@ static void GL_BINDING_CALL Mock_glShaderSource(GLuint shader, GLsizei count, const char* const* str, const GLint* length); -static void GL_BINDING_CALL -Mock_glStencilFunc(GLenum func, GLint ref, GLuint mask); -static void GL_BINDING_CALL -Mock_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); +static void GL_BINDING_CALL Mock_glStencilFunc(GLenum func, + GLint ref, + GLuint mask); +static void GL_BINDING_CALL Mock_glStencilFuncSeparate(GLenum face, + GLenum func, + GLint ref, + GLuint mask); static void GL_BINDING_CALL Mock_glStencilMask(GLuint mask); -static void GL_BINDING_CALL -Mock_glStencilMaskSeparate(GLenum face, GLuint mask); -static void GL_BINDING_CALL -Mock_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); -static void GL_BINDING_CALL -Mock_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); +static void GL_BINDING_CALL Mock_glStencilMaskSeparate(GLenum face, + GLuint mask); +static void GL_BINDING_CALL Mock_glStencilOp(GLenum fail, + GLenum zfail, + GLenum zpass); +static void GL_BINDING_CALL Mock_glStencilOpSeparate(GLenum face, + GLenum fail, + GLenum zfail, + GLenum zpass); static GLboolean GL_BINDING_CALL Mock_glTestFenceAPPLE(GLuint fence); static GLboolean GL_BINDING_CALL Mock_glTestFenceNV(GLuint fence); static void GL_BINDING_CALL Mock_glTexImage2D(GLenum target, @@ -721,14 +805,18 @@ static void GL_BINDING_CALL Mock_glTexImage3D(GLenum target, GLenum format, GLenum type, const void* pixels); -static void GL_BINDING_CALL -Mock_glTexParameterf(GLenum target, GLenum pname, GLfloat param); -static void GL_BINDING_CALL -Mock_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params); -static void GL_BINDING_CALL -Mock_glTexParameteri(GLenum target, GLenum pname, GLint param); -static void GL_BINDING_CALL -Mock_glTexParameteriv(GLenum target, GLenum pname, const GLint* params); +static void GL_BINDING_CALL Mock_glTexParameterf(GLenum target, + GLenum pname, + GLfloat param); +static void GL_BINDING_CALL Mock_glTexParameterfv(GLenum target, + GLenum pname, + const GLfloat* params); +static void GL_BINDING_CALL Mock_glTexParameteri(GLenum target, + GLenum pname, + GLint param); +static void GL_BINDING_CALL Mock_glTexParameteriv(GLenum target, + GLenum pname, + const GLint* params); static void GL_BINDING_CALL Mock_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, @@ -760,49 +848,69 @@ Mock_glTransformFeedbackVaryings(GLuint program, const char* const* varyings, GLenum bufferMode); static void GL_BINDING_CALL Mock_glUniform1f(GLint location, GLfloat x); -static void GL_BINDING_CALL -Mock_glUniform1fv(GLint location, GLsizei count, const GLfloat* v); +static void GL_BINDING_CALL Mock_glUniform1fv(GLint location, + GLsizei count, + const GLfloat* v); static void GL_BINDING_CALL Mock_glUniform1i(GLint location, GLint x); -static void GL_BINDING_CALL -Mock_glUniform1iv(GLint location, GLsizei count, const GLint* v); +static void GL_BINDING_CALL Mock_glUniform1iv(GLint location, + GLsizei count, + const GLint* v); static void GL_BINDING_CALL Mock_glUniform1ui(GLint location, GLuint v0); -static void GL_BINDING_CALL -Mock_glUniform1uiv(GLint location, GLsizei count, const GLuint* v); -static void GL_BINDING_CALL -Mock_glUniform2f(GLint location, GLfloat x, GLfloat y); -static void GL_BINDING_CALL -Mock_glUniform2fv(GLint location, GLsizei count, const GLfloat* v); +static void GL_BINDING_CALL Mock_glUniform1uiv(GLint location, + GLsizei count, + const GLuint* v); +static void GL_BINDING_CALL Mock_glUniform2f(GLint location, + GLfloat x, + GLfloat y); +static void GL_BINDING_CALL Mock_glUniform2fv(GLint location, + GLsizei count, + const GLfloat* v); static void GL_BINDING_CALL Mock_glUniform2i(GLint location, GLint x, GLint y); -static void GL_BINDING_CALL -Mock_glUniform2iv(GLint location, GLsizei count, const GLint* v); -static void GL_BINDING_CALL -Mock_glUniform2ui(GLint location, GLuint v0, GLuint v1); -static void GL_BINDING_CALL -Mock_glUniform2uiv(GLint location, GLsizei count, const GLuint* v); -static void GL_BINDING_CALL -Mock_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z); -static void GL_BINDING_CALL -Mock_glUniform3fv(GLint location, GLsizei count, const GLfloat* v); -static void GL_BINDING_CALL -Mock_glUniform3i(GLint location, GLint x, GLint y, GLint z); -static void GL_BINDING_CALL -Mock_glUniform3iv(GLint location, GLsizei count, const GLint* v); -static void GL_BINDING_CALL -Mock_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2); -static void GL_BINDING_CALL -Mock_glUniform3uiv(GLint location, GLsizei count, const GLuint* v); +static void GL_BINDING_CALL Mock_glUniform2iv(GLint location, + GLsizei count, + const GLint* v); +static void GL_BINDING_CALL Mock_glUniform2ui(GLint location, + GLuint v0, + GLuint v1); +static void GL_BINDING_CALL Mock_glUniform2uiv(GLint location, + GLsizei count, + const GLuint* v); +static void GL_BINDING_CALL Mock_glUniform3f(GLint location, + GLfloat x, + GLfloat y, + GLfloat z); +static void GL_BINDING_CALL Mock_glUniform3fv(GLint location, + GLsizei count, + const GLfloat* v); +static void GL_BINDING_CALL Mock_glUniform3i(GLint location, + GLint x, + GLint y, + GLint z); +static void GL_BINDING_CALL Mock_glUniform3iv(GLint location, + GLsizei count, + const GLint* v); +static void GL_BINDING_CALL Mock_glUniform3ui(GLint location, + GLuint v0, + GLuint v1, + GLuint v2); +static void GL_BINDING_CALL Mock_glUniform3uiv(GLint location, + GLsizei count, + const GLuint* v); static void GL_BINDING_CALL Mock_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -static void GL_BINDING_CALL -Mock_glUniform4fv(GLint location, GLsizei count, const GLfloat* v); +static void GL_BINDING_CALL Mock_glUniform4fv(GLint location, + GLsizei count, + const GLfloat* v); static void GL_BINDING_CALL Mock_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w); -static void GL_BINDING_CALL -Mock_glUniform4iv(GLint location, GLsizei count, const GLint* v); +static void GL_BINDING_CALL Mock_glUniform4iv(GLint location, + GLsizei count, + const GLint* v); static void GL_BINDING_CALL Mock_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); -static void GL_BINDING_CALL -Mock_glUniform4uiv(GLint location, GLsizei count, const GLuint* v); +static void GL_BINDING_CALL Mock_glUniform4uiv(GLint location, + GLsizei count, + const GLuint* v); static void GL_BINDING_CALL Mock_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, @@ -848,34 +956,37 @@ static GLboolean GL_BINDING_CALL Mock_glUnmapBufferOES(GLenum target); static void GL_BINDING_CALL Mock_glUseProgram(GLuint program); static void GL_BINDING_CALL Mock_glValidateProgram(GLuint program); static void GL_BINDING_CALL Mock_glVertexAttrib1f(GLuint indx, GLfloat x); -static void GL_BINDING_CALL -Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values); -static void GL_BINDING_CALL -Mock_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); -static void GL_BINDING_CALL -Mock_glVertexAttrib2fv(GLuint indx, const GLfloat* values); -static void GL_BINDING_CALL -Mock_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); -static void GL_BINDING_CALL -Mock_glVertexAttrib3fv(GLuint indx, const GLfloat* values); +static void GL_BINDING_CALL Mock_glVertexAttrib1fv(GLuint indx, + const GLfloat* values); +static void GL_BINDING_CALL Mock_glVertexAttrib2f(GLuint indx, + GLfloat x, + GLfloat y); +static void GL_BINDING_CALL Mock_glVertexAttrib2fv(GLuint indx, + const GLfloat* values); +static void GL_BINDING_CALL Mock_glVertexAttrib3f(GLuint indx, + GLfloat x, + GLfloat y, + GLfloat z); +static void GL_BINDING_CALL Mock_glVertexAttrib3fv(GLuint indx, + const GLfloat* values); static void GL_BINDING_CALL Mock_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -static void GL_BINDING_CALL -Mock_glVertexAttrib4fv(GLuint indx, const GLfloat* values); -static void GL_BINDING_CALL -Mock_glVertexAttribDivisor(GLuint index, GLuint divisor); -static void GL_BINDING_CALL -Mock_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor); -static void GL_BINDING_CALL -Mock_glVertexAttribDivisorARB(GLuint index, GLuint divisor); +static void GL_BINDING_CALL Mock_glVertexAttrib4fv(GLuint indx, + const GLfloat* values); +static void GL_BINDING_CALL Mock_glVertexAttribDivisor(GLuint index, + GLuint divisor); +static void GL_BINDING_CALL Mock_glVertexAttribDivisorANGLE(GLuint index, + GLuint divisor); +static void GL_BINDING_CALL Mock_glVertexAttribDivisorARB(GLuint index, + GLuint divisor); static void GL_BINDING_CALL Mock_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w); -static void GL_BINDING_CALL -Mock_glVertexAttribI4iv(GLuint indx, const GLint* values); +static void GL_BINDING_CALL Mock_glVertexAttribI4iv(GLuint indx, + const GLint* values); static void GL_BINDING_CALL Mock_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w); -static void GL_BINDING_CALL -Mock_glVertexAttribI4uiv(GLuint indx, const GLuint* values); +static void GL_BINDING_CALL Mock_glVertexAttribI4uiv(GLuint indx, + const GLuint* values); static void GL_BINDING_CALL Mock_glVertexAttribIPointer(GLuint indx, GLint size, GLenum type, @@ -887,7 +998,10 @@ static void GL_BINDING_CALL Mock_glVertexAttribPointer(GLuint indx, GLboolean normalized, GLsizei stride, const void* ptr); -static void GL_BINDING_CALL -Mock_glViewport(GLint x, GLint y, GLsizei width, GLsizei height); -static GLenum GL_BINDING_CALL -Mock_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +static void GL_BINDING_CALL Mock_glViewport(GLint x, + GLint y, + GLsizei width, + GLsizei height); +static GLenum GL_BINDING_CALL Mock_glWaitSync(GLsync sync, + GLbitfield flags, + GLuint64 timeout); diff --git a/ui/gl/gl_bindings_skia_in_process.cc b/ui/gl/gl_bindings_skia_in_process.cc index 709c37fa9ef..8305a850b6a 100644 --- a/ui/gl/gl_bindings_skia_in_process.cc +++ b/ui/gl/gl_bindings_skia_in_process.cc @@ -64,6 +64,10 @@ GLvoid StubGLBindVertexArray(GLuint array) { glBindVertexArrayOES(array); } +GLvoid StubGLBlendBarrier(void) { + glBlendBarrierKHR(); +} + GLvoid StubGLBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { glBlendColor(red, green, blue, alpha); @@ -657,6 +661,44 @@ GLint StubGLGetProgramResourceLocation(GLuint program, return glGetProgramResourceLocation(program, programInterface, name); } +GLvoid StubGLDebugMessageControl(GLenum source, GLenum type, GLenum severity, + GLsizei count, const GLuint *ids, + GLboolean enabled) { + glDebugMessageControlKHR(source, type, severity, count, ids, enabled); +} + +GLvoid StubGLDebugMessageInsert(GLenum source, GLenum type, GLuint id, + GLenum severity, GLsizei length, + const GLchar *buf) { + glDebugMessageInsertKHR(source, type, id, severity, length, buf); +} + +GLvoid StubGLDebugMessageCallback(GLDEBUGPROCKHR callback, + const void *userParam) { + glDebugMessageCallbackKHR(callback, userParam); +} + +GLuint StubGLGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, + GLenum *types, GLuint *ids, GLenum *severities, + GLsizei *lengths, GLchar *messageLog) { + return glGetDebugMessageLogKHR(count, bufSize, sources, types, ids, + severities, lengths, messageLog); +} + +GLvoid StubGLPushDebugGroup(GLenum source, GLuint id, GLsizei length, + const GLchar *message) { + glPushDebugGroupKHR(source, id, length, message); +} + +GLvoid StubGLPopDebugGroup(void) { + glPopDebugGroupKHR(); +} + +GLvoid StubGLObjectLabel(GLenum identifier, GLuint name, GLsizei length, + const GLchar *label) { + glObjectLabelKHR(identifier, name, length, label); +} + } // extern "C" } // namespace @@ -706,6 +748,7 @@ GrGLInterface* CreateInProcessSkiaGLBinding() { functions->fBindFragDataLocation = StubGLBindFragDataLocation; functions->fBindTexture = StubGLBindTexture; functions->fBindVertexArray = StubGLBindVertexArray; + functions->fBlendBarrier = StubGLBlendBarrier; functions->fBlendColor = StubGLBlendColor; functions->fBlendEquation = StubGLBlendEquation; functions->fBlendFunc = StubGLBlendFunc; @@ -847,6 +890,14 @@ GrGLInterface* CreateInProcessSkiaGLBinding() { functions->fBindFragDataLocationIndexed = StubGLBindFragDataLocationIndexed; functions->fGetProgramResourceLocation = StubGLGetProgramResourceLocation; + functions->fDebugMessageControl = StubGLDebugMessageControl; + functions->fDebugMessageInsert = StubGLDebugMessageInsert; + functions->fDebugMessageCallback = + reinterpret_cast(StubGLDebugMessageCallback); + functions->fGetDebugMessageLog = StubGLGetDebugMessageLog; + functions->fPushDebugGroup = StubGLPushDebugGroup; + functions->fPopDebugGroup = StubGLPopDebugGroup; + functions->fObjectLabel = StubGLObjectLabel; return interface; } diff --git a/ui/gl/gl_enums_implementation_autogen.h b/ui/gl/gl_enums_implementation_autogen.h index da97baabe11..c42fb2c2592 100644 --- a/ui/gl/gl_enums_implementation_autogen.h +++ b/ui/gl/gl_enums_implementation_autogen.h @@ -10,4432 +10,3325 @@ static const GLEnums::EnumToString enum_to_string_table[] = { { - 0x8D77, - "GL_RGB16UI", + 0x8D77, "GL_RGB16UI", }, { - 0x8D76, - "GL_RGBA16UI", + 0x8D76, "GL_RGBA16UI", }, { - 0x9260, - "GL_GCCSO_SHADER_BINARY_FJ", + 0x9260, "GL_GCCSO_SHADER_BINARY_FJ", }, { - 0x9009, - "GL_TEXTURE_CUBE_MAP_ARRAY_EXT", + 0x9009, "GL_TEXTURE_CUBE_MAP_ARRAY_EXT", }, { - 0x8D71, - "GL_RGB32UI", + 0x8D71, "GL_RGB32UI", }, { - 0x8D70, - "GL_RGBA32UI", + 0x8D70, "GL_RGBA32UI", }, { - 0x8C76, - "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH", + 0x8C76, "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH", }, { - 0x8825, - "GL_DRAW_BUFFER0_EXT", + 0x8825, "GL_DRAW_BUFFER0_EXT", }, { - 0x8D94, - "GL_RED_INTEGER", + 0x8D94, "GL_RED_INTEGER", }, { - 0x0BC1, - "GL_ALPHA_TEST_FUNC_QCOM", + 0x0BC1, "GL_ALPHA_TEST_FUNC_QCOM", }, { - 0x884C, - "GL_TEXTURE_COMPARE_MODE_EXT", + 0x884C, "GL_TEXTURE_COMPARE_MODE_EXT", }, { - 0x0BC2, - "GL_ALPHA_TEST_REF_QCOM", + 0x0BC2, "GL_ALPHA_TEST_REF_QCOM", }, { - 0x78EF, - "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM", + 0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM", }, { - 0x884D, - "GL_TEXTURE_COMPARE_FUNC_EXT", + 0x884D, "GL_TEXTURE_COMPARE_FUNC_EXT", }, { - 0x884E, - "GL_COMPARE_REF_TO_TEXTURE_EXT", + 0x884E, "GL_COMPARE_REF_TO_TEXTURE_EXT", }, { - 0x8E76, - "GL_TESS_GEN_MODE_EXT", + 0x8E76, "GL_TESS_GEN_MODE_EXT", }, { - 0x8E77, - "GL_TESS_GEN_SPACING_EXT", + 0x8E77, "GL_TESS_GEN_SPACING_EXT", }, { - 0x000D, - "GL_TRIANGLE_STRIP_ADJACENCY_EXT", + 0x000D, "GL_TRIANGLE_STRIP_ADJACENCY_EXT", }, { - 0x000E, - "GL_PATCHES_EXT", + 0x000E, "GL_PATCHES_EXT", }, { - 0x000B, - "GL_LINE_STRIP_ADJACENCY_EXT", + 0x000B, "GL_LINE_STRIP_ADJACENCY_EXT", }, { - 0x000C, - "GL_TRIANGLES_ADJACENCY_EXT", + 0x000C, "GL_TRIANGLES_ADJACENCY_EXT", }, { - 0x000A, - "GL_LINES_ADJACENCY_EXT", + 0x000A, "GL_LINES_ADJACENCY_EXT", }, { - 0x92CF, - "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT", + 0x92CF, "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT", }, { - 0x93A1, - "GL_BGRA8_EXT", + 0x93A1, "GL_BGRA8_EXT", }, { - 0x813C, - "GL_TEXTURE_BASE_LEVEL", + 0x813C, "GL_TEXTURE_BASE_LEVEL", }, { - 0, - "GL_FALSE", + 0, "GL_FALSE", }, { - 0x00400000, - "GL_STENCIL_BUFFER_BIT6_QCOM", + 0x00400000, "GL_STENCIL_BUFFER_BIT6_QCOM", }, { - 0x9500, - "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL", + 0x9500, "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL", }, { - 0x78F2, - "GL_SCANOUT_CHROMIUM", + 0x78F2, "GL_SCANOUT_CHROMIUM", }, { - 0x9138, - "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG", + 0x9138, "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG", }, { - 0x8FC4, - "GL_SHADER_BINARY_VIV", + 0x8FC4, "GL_SHADER_BINARY_VIV", }, { - 0x9130, - "GL_SGX_PROGRAM_BINARY_IMG", + 0x9130, "GL_SGX_PROGRAM_BINARY_IMG", }, { - 0x9133, - "GL_RENDERBUFFER_SAMPLES_IMG", + 0x9133, "GL_RENDERBUFFER_SAMPLES_IMG", }, { - 0x82E0, - "GL_BUFFER_KHR", + 0x82E0, "GL_BUFFER_KHR", }, { - 0x9135, - "GL_MAX_SAMPLES_IMG", + 0x9135, "GL_MAX_SAMPLES_IMG", }, { - 0x9134, - "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG", + 0x9134, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG", }, { - 0x9137, - "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG", + 0x9137, "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG", }, { - 0x9136, - "GL_TEXTURE_SAMPLES_IMG", + 0x9136, "GL_TEXTURE_SAMPLES_IMG", }, { - 0x8D88, - "GL_RGBA16I", + 0x8D88, "GL_RGBA16I", }, { - 0x8D89, - "GL_RGB16I", + 0x8D89, "GL_RGB16I", }, { - 0x00000020, - "GL_COLOR_BUFFER_BIT5_QCOM", + 0x00000020, "GL_COLOR_BUFFER_BIT5_QCOM", }, { - 0x0008, - "GL_MAP_INVALIDATE_BUFFER_BIT_EXT", + 0x0008, "GL_MAP_INVALIDATE_BUFFER_BIT_EXT", }, { - 0x0BC0, - "GL_ALPHA_TEST_QCOM", + 0x0BC0, "GL_ALPHA_TEST_QCOM", }, { - 0x0006, - "GL_TRIANGLE_FAN", + 0x0006, "GL_TRIANGLE_FAN", }, { - 0x0007, - "GL_QUADS_EXT", + 0x0007, "GL_QUADS_EXT", }, { - 0x0004, - "GL_TRIANGLES", + 0x0004, "GL_TRIANGLES", }, { - 0x0005, - "GL_TRIANGLE_STRIP", + 0x0005, "GL_TRIANGLE_STRIP", }, { - 0x0002, - "GL_LINE_LOOP", + 0x0002, "GL_LINE_LOOP", }, { - 0x0003, - "GL_LINE_STRIP", + 0x0003, "GL_LINE_STRIP", }, { - 0x0000, - "GL_POINTS", + 0x0000, "GL_POINTS", }, { - 0x0001, - "GL_LINES", + 0x0001, "GL_LINES", }, { - 0x8D7D, - "GL_RGB8UI", + 0x8D7D, "GL_RGB8UI", }, { - 0x93F0, - "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG", + 0x93F0, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG", }, { - 0x93F1, - "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG", + 0x93F1, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG", }, { - 0x0D04, - "GL_PACK_SKIP_PIXELS", + 0x0D04, "GL_PACK_SKIP_PIXELS", }, { - 0x900E, - "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", + 0x900E, "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", }, { - 0x900D, - "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT", + 0x900D, "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT", }, { - 0x8C7F, - "GL_TRANSFORM_FEEDBACK_BUFFER_MODE", + 0x8C7F, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE", }, { - 0x900F, - "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", + 0x900F, "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", }, { - 0x900A, - "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT", + 0x900A, "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT", }, { - 0x900C, - "GL_SAMPLER_CUBE_MAP_ARRAY_EXT", + 0x900C, "GL_SAMPLER_CUBE_MAP_ARRAY_EXT", }, { - 0x88B8, - "GL_READ_ONLY", + 0x88B8, "GL_READ_ONLY", }, { - 0x88B9, - "GL_WRITE_ONLY_OES", + 0x88B9, "GL_WRITE_ONLY_OES", }, { - 0x8211, - "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT", + 0x8211, "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT", }, { - 0x8210, - "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT", + 0x8210, "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT", }, { - 0x8741, - "GL_PROGRAM_BINARY_LENGTH_OES", + 0x8741, "GL_PROGRAM_BINARY_LENGTH_OES", }, { - 0x8740, - "GL_Z400_BINARY_AMD", + 0x8740, "GL_Z400_BINARY_AMD", }, { - 0x8215, - "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", + 0x8215, "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", }, { - 0x8C4D, - "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV", + 0x8C4D, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV", }, { - 0x8192, - "GL_GENERATE_MIPMAP_HINT", + 0x8192, "GL_GENERATE_MIPMAP_HINT", }, { - 0x8E79, - "GL_TESS_GEN_POINT_MODE_EXT", + 0x8E79, "GL_TESS_GEN_POINT_MODE_EXT", }, { - 0x8A54, - "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT", + 0x8A54, "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT", }, { - 0x8A55, - "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT", + 0x8A55, "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT", }, { - 0x8A56, - "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT", + 0x8A56, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT", }, { - 0x8A57, - "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT", + 0x8A57, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT", }, { - 0x8A51, - "GL_RGB_RAW_422_APPLE", + 0x8A51, "GL_RGB_RAW_422_APPLE", }, { - 0x87F9, - "GL_3DC_X_AMD", + 0x87F9, "GL_3DC_X_AMD", }, { - 0x8A53, - "GL_SYNC_OBJECT_APPLE", + 0x8A53, "GL_SYNC_OBJECT_APPLE", }, { - 0x8DF8, - "GL_SHADER_BINARY_FORMATS", + 0x8DF8, "GL_SHADER_BINARY_FORMATS", }, { - 0x8DF9, - "GL_NUM_SHADER_BINARY_FORMATS", + 0x8DF9, "GL_NUM_SHADER_BINARY_FORMATS", }, { - 0x826D, - "GL_DEBUG_GROUP_STACK_DEPTH_KHR", + 0x826D, "GL_DEBUG_GROUP_STACK_DEPTH_KHR", }, { - 0x8E75, - "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT", + 0x8E75, "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT", }, { - 0x826B, - "GL_DEBUG_SEVERITY_NOTIFICATION_KHR", + 0x826B, "GL_DEBUG_SEVERITY_NOTIFICATION_KHR", }, { - 0x826C, - "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR", + 0x826C, "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR", }, { - 0x8B59, - "GL_BOOL_VEC4", + 0x8B59, "GL_BOOL_VEC4", }, { - 0x826A, - "GL_DEBUG_TYPE_POP_GROUP_KHR", + 0x826A, "GL_DEBUG_TYPE_POP_GROUP_KHR", }, { - 0x8B57, - "GL_BOOL_VEC2", + 0x8B57, "GL_BOOL_VEC2", }, { - 0x8DF1, - "GL_MEDIUM_FLOAT", + 0x8DF1, "GL_MEDIUM_FLOAT", }, { - 0x8B55, - "GL_INT_VEC4", + 0x8B55, "GL_INT_VEC4", }, { - 0x8B54, - "GL_INT_VEC3", + 0x8B54, "GL_INT_VEC3", }, { - 0x8DF4, - "GL_MEDIUM_INT", + 0x8DF4, "GL_MEDIUM_INT", }, { - 0x8DF5, - "GL_HIGH_INT", + 0x8DF5, "GL_HIGH_INT", }, { - 0x8B51, - "GL_FLOAT_VEC3", + 0x8B51, "GL_FLOAT_VEC3", }, { - 0x8B50, - "GL_FLOAT_VEC2", + 0x8B50, "GL_FLOAT_VEC2", }, { - 0x806D, - "GL_UNPACK_SKIP_IMAGES", + 0x806D, "GL_UNPACK_SKIP_IMAGES", }, { - 0x806E, - "GL_UNPACK_IMAGE_HEIGHT", + 0x806E, "GL_UNPACK_IMAGE_HEIGHT", }, { - 0x806F, - "GL_TEXTURE_3D_OES", + 0x806F, "GL_TEXTURE_3D_OES", }, { - 0x92E7, - "GL_IS_PER_PATCH_EXT", + 0x92E7, "GL_IS_PER_PATCH_EXT", }, { - 0x92E0, - "GL_DEBUG_OUTPUT_KHR", + 0x92E0, "GL_DEBUG_OUTPUT_KHR", }, { - 0x806A, - "GL_TEXTURE_BINDING_3D_OES", + 0x806A, "GL_TEXTURE_BINDING_3D_OES", }, { - 0x8D8E, - "GL_RGBA8I", + 0x8D8E, "GL_RGBA8I", }, { - 0x8CE3, - "GL_COLOR_ATTACHMENT3_EXT", + 0x8CE3, "GL_COLOR_ATTACHMENT3_EXT", }, { - 0x9274, - "GL_COMPRESSED_RGB8_ETC2", + 0x9274, "GL_COMPRESSED_RGB8_ETC2", }, { - 0x1904, - "GL_GREEN_NV", + 0x1904, "GL_GREEN_NV", }, { - 0x928D, - "GL_DST_OUT_NV", + 0x928D, "GL_DST_OUT_NV", }, { - 0x8069, - "GL_TEXTURE_BINDING_2D", + 0x8069, "GL_TEXTURE_BINDING_2D", }, { - 0x8A2E, - "GL_MAX_COMBINED_UNIFORM_BLOCKS", + 0x8A2E, "GL_MAX_COMBINED_UNIFORM_BLOCKS", }, { - 0x8F96, - "GL_RGB8_SNORM", + 0x8F96, "GL_RGB8_SNORM", }, { - 0x8F95, - "GL_RG8_SNORM", + 0x8F95, "GL_RG8_SNORM", }, { - 0x8260, - "GL_UNDEFINED_VERTEX_EXT", + 0x8260, "GL_UNDEFINED_VERTEX_EXT", }, { - 0x8261, - "GL_NO_RESET_NOTIFICATION_KHR", + 0x8261, "GL_NO_RESET_NOTIFICATION_KHR", }, { - 0x0D02, - "GL_PACK_ROW_LENGTH", + 0x0D02, "GL_PACK_ROW_LENGTH", }, { - 0x8DFA, - "GL_SHADER_COMPILER", + 0x8DFA, "GL_SHADER_COMPILER", }, { - 0x8DFB, - "GL_MAX_VERTEX_UNIFORM_VECTORS", + 0x8DFB, "GL_MAX_VERTEX_UNIFORM_VECTORS", }, { - 0x8DFC, - "GL_MAX_VARYING_VECTORS", + 0x8DFC, "GL_MAX_VARYING_VECTORS", }, { - 0x8B5C, - "GL_FLOAT_MAT4", + 0x8B5C, "GL_FLOAT_MAT4", }, { - 0x8B5B, - "GL_FLOAT_MAT3", + 0x8B5B, "GL_FLOAT_MAT3", }, { - 0x8268, - "GL_DEBUG_TYPE_MARKER_KHR", + 0x8268, "GL_DEBUG_TYPE_MARKER_KHR", }, { - 0x8269, - "GL_DEBUG_TYPE_PUSH_GROUP_KHR", + 0x8269, "GL_DEBUG_TYPE_PUSH_GROUP_KHR", }, { - 0x8A43, - "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", + 0x8A43, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", }, { - 0x1905, - "GL_BLUE_NV", + 0x1905, "GL_BLUE_NV", }, { - 0x87FF, - "GL_PROGRAM_BINARY_FORMATS_OES", + 0x87FF, "GL_PROGRAM_BINARY_FORMATS_OES", }, { - 0x87FE, - "GL_NUM_PROGRAM_BINARY_FORMATS_OES", + 0x87FE, "GL_NUM_PROGRAM_BINARY_FORMATS_OES", }, { - 0x8A41, - "GL_UNIFORM_BLOCK_NAME_LENGTH", + 0x8A41, "GL_UNIFORM_BLOCK_NAME_LENGTH", }, { - 0x2600, - "GL_NEAREST", + 0x2600, "GL_NEAREST", }, { - 0x2601, - "GL_LINEAR", + 0x2601, "GL_LINEAR", }, { - 0x8C03, - "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG", + 0x8C03, "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG", }, { - 0x821B, - "GL_MAJOR_VERSION", + 0x821B, "GL_MAJOR_VERSION", }, { - 0x821A, - "GL_DEPTH_STENCIL_ATTACHMENT", + 0x821A, "GL_DEPTH_STENCIL_ATTACHMENT", }, { - 0x8A40, - "GL_UNIFORM_BLOCK_DATA_SIZE", + 0x8A40, "GL_UNIFORM_BLOCK_DATA_SIZE", }, { - 0x9242, - "GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM", + 0x9242, "GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM", }, { - 0x821D, - "GL_NUM_EXTENSIONS", + 0x821D, "GL_NUM_EXTENSIONS", }, { - 0x88BB, - "GL_BUFFER_ACCESS_OES", + 0x88BB, "GL_BUFFER_ACCESS_OES", }, { - 0x88BC, - "GL_BUFFER_MAPPED_OES", + 0x88BC, "GL_BUFFER_MAPPED_OES", }, { - 0x88BD, - "GL_BUFFER_MAP_POINTER_OES", + 0x88BD, "GL_BUFFER_MAP_POINTER_OES", }, { - 0x88BF, - "GL_TIME_ELAPSED_EXT", + 0x88BF, "GL_TIME_ELAPSED_EXT", }, { - 0x8A46, - "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", + 0x8A46, "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", }, { - 0x6003, - "GL_GET_ERROR_QUERY_CHROMIUM", + 0x6003, "GL_GET_ERROR_QUERY_CHROMIUM", }, { - 0x8F94, - "GL_R8_SNORM", + 0x8F94, "GL_R8_SNORM", }, { - 0x0C10, - "GL_SCISSOR_BOX", + 0x0C10, "GL_SCISSOR_BOX", }, { - 0x0C11, - "GL_SCISSOR_TEST", + 0x0C11, "GL_SCISSOR_TEST", }, { - 0x1700, - "GL_PATH_MODELVIEW_CHROMIUM", + 0x1700, "GL_PATH_MODELVIEW_CHROMIUM", }, { - 0x80000000, - "GL_MULTISAMPLE_BUFFER_BIT7_QCOM", + 0x80000000, "GL_MULTISAMPLE_BUFFER_BIT7_QCOM", }, { - 0x94F8, - "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL", + 0x94F8, "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL", }, { - 0x8A48, - "GL_TEXTURE_SRGB_DECODE_EXT", + 0x8A48, "GL_TEXTURE_SRGB_DECODE_EXT", }, { - 0x300E, - "GL_CONTEXT_LOST", + 0x300E, "GL_CONTEXT_LOST", }, { - 0x02000000, - "GL_MULTISAMPLE_BUFFER_BIT1_QCOM", + 0x02000000, "GL_MULTISAMPLE_BUFFER_BIT1_QCOM", }, { - 0x8C2F, - "GL_ANY_SAMPLES_PASSED_EXT", + 0x8C2F, "GL_ANY_SAMPLES_PASSED_EXT", }, { - 0x8BD2, - "GL_TEXTURE_WIDTH_QCOM", + 0x8BD2, "GL_TEXTURE_WIDTH_QCOM", }, { - 0x8C2D, - "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT", + 0x8C2D, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT", }, { - 0x8C2C, - "GL_TEXTURE_BINDING_BUFFER_EXT", + 0x8C2C, "GL_TEXTURE_BINDING_BUFFER_EXT", }, { - 0x8C2B, - "GL_MAX_TEXTURE_BUFFER_SIZE_EXT", + 0x8C2B, "GL_MAX_TEXTURE_BUFFER_SIZE_EXT", }, { - 0x8C2A, - "GL_TEXTURE_BUFFER_EXT", + 0x8C2A, "GL_TEXTURE_BUFFER_EXT", }, { - 0x8BD7, - "GL_TEXTURE_TYPE_QCOM", + 0x8BD7, "GL_TEXTURE_TYPE_QCOM", }, { - 0x8B8D, - "GL_CURRENT_PROGRAM", + 0x8B8D, "GL_CURRENT_PROGRAM", }, { - 0x8BD9, - "GL_TEXTURE_NUM_LEVELS_QCOM", + 0x8BD9, "GL_TEXTURE_NUM_LEVELS_QCOM", }, { - 0x00200000, - "GL_STENCIL_BUFFER_BIT5_QCOM", + 0x00200000, "GL_STENCIL_BUFFER_BIT5_QCOM", }, { - 0x8D9F, - "GL_INT_2_10_10_10_REV", + 0x8D9F, "GL_INT_2_10_10_10_REV", }, { - 0x8B8A, - "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH", + 0x8B8A, "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH", }, { - 0x8B8B, - "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES", + 0x8B8B, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES", }, { - 0x8B8C, - "GL_SHADING_LANGUAGE_VERSION", + 0x8B8C, "GL_SHADING_LANGUAGE_VERSION", }, { - 0x8BDA, - "GL_TEXTURE_TARGET_QCOM", + 0x8BDA, "GL_TEXTURE_TARGET_QCOM", }, { - 0x8BDB, - "GL_TEXTURE_OBJECT_VALID_QCOM", + 0x8BDB, "GL_TEXTURE_OBJECT_VALID_QCOM", }, { - 0x8BDC, - "GL_STATE_RESTORE", + 0x8BDC, "GL_STATE_RESTORE", }, { - 0x8B88, - "GL_SHADER_SOURCE_LENGTH", + 0x8B88, "GL_SHADER_SOURCE_LENGTH", }, { - 0x8B89, - "GL_ACTIVE_ATTRIBUTES", + 0x8B89, "GL_ACTIVE_ATTRIBUTES", }, { - 0x93C9, - "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES", + 0x93C9, "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES", }, { - 0x93C8, - "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES", + 0x93C8, "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES", }, { - 0x8B84, - "GL_INFO_LOG_LENGTH", + 0x8B84, "GL_INFO_LOG_LENGTH", }, { - 0x8B85, - "GL_ATTACHED_SHADERS", + 0x8B85, "GL_ATTACHED_SHADERS", }, { - 0x8B86, - "GL_ACTIVE_UNIFORMS", + 0x8B86, "GL_ACTIVE_UNIFORMS", }, { - 0x8B87, - "GL_ACTIVE_UNIFORM_MAX_LENGTH", + 0x8B87, "GL_ACTIVE_UNIFORM_MAX_LENGTH", }, { - 0x8B80, - "GL_DELETE_STATUS", + 0x8B80, "GL_DELETE_STATUS", }, { - 0x8B81, - "GL_COMPILE_STATUS", + 0x8B81, "GL_COMPILE_STATUS", }, { - 0x8B82, - "GL_LINK_STATUS", + 0x8B82, "GL_LINK_STATUS", }, { - 0x8B83, - "GL_VALIDATE_STATUS", + 0x8B83, "GL_VALIDATE_STATUS", }, { - 0x9380, - "GL_NUM_SAMPLE_COUNTS", + 0x9380, "GL_NUM_SAMPLE_COUNTS", }, { - 0x8D48, - "GL_STENCIL_INDEX8", + 0x8D48, "GL_STENCIL_INDEX8", }, { - 0x8D46, - "GL_STENCIL_INDEX1_OES", + 0x8D46, "GL_STENCIL_INDEX1_OES", }, { - 0x8D47, - "GL_STENCIL_INDEX4_OES", + 0x8D47, "GL_STENCIL_INDEX4_OES", }, { - 0x8D44, - "GL_RENDERBUFFER_INTERNAL_FORMAT", + 0x8D44, "GL_RENDERBUFFER_INTERNAL_FORMAT", }, { - 0x00000100, - "GL_DEPTH_BUFFER_BIT", + 0x00000100, "GL_DEPTH_BUFFER_BIT", }, { - 0x8D42, - "GL_RENDERBUFFER_WIDTH", + 0x8D42, "GL_RENDERBUFFER_WIDTH", }, { - 0x8D43, - "GL_RENDERBUFFER_HEIGHT", + 0x8D43, "GL_RENDERBUFFER_HEIGHT", }, { - 0x8D40, - "GL_FRAMEBUFFER", + 0x8D40, "GL_FRAMEBUFFER", }, { - 0x8D41, - "GL_RENDERBUFFER", + 0x8D41, "GL_RENDERBUFFER", }, { - 0x8A3A, - "GL_UNIFORM_BLOCK_INDEX", + 0x8A3A, "GL_UNIFORM_BLOCK_INDEX", }, { - 0x0BD0, - "GL_DITHER", + 0x0BD0, "GL_DITHER", }, { - 0x93D3, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", + 0x93D3, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", }, { - 0x9144, - "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR", + 0x9144, "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR", }, { - 0x1801, - "GL_DEPTH_EXT", + 0x1801, "GL_DEPTH_EXT", }, { - 0x1800, - "GL_COLOR_EXT", + 0x1800, "GL_COLOR_EXT", }, { - 0x1802, - "GL_STENCIL_EXT", + 0x1802, "GL_STENCIL_EXT", }, { - 0x9288, - "GL_SRC_OVER_NV", + 0x9288, "GL_SRC_OVER_NV", }, { - 0x9120, - "GL_BUFFER_MAP_LENGTH", + 0x9120, "GL_BUFFER_MAP_LENGTH", }, { - 0x0B21, - "GL_LINE_WIDTH", + 0x0B21, "GL_LINE_WIDTH", }, { - 0x9308, - "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT", + 0x9308, "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT", }, { - 0x81A5, - "GL_DEPTH_COMPONENT16", + 0x81A5, "GL_DEPTH_COMPONENT16", }, { - 0x81A6, - "GL_DEPTH_COMPONENT24_OES", + 0x81A6, "GL_DEPTH_COMPONENT24_OES", }, { - 0x81A7, - "GL_DEPTH_COMPONENT32_OES", + 0x81A7, "GL_DEPTH_COMPONENT32_OES", }, { - 0x88FD, - "GL_VERTEX_ATTRIB_ARRAY_INTEGER", + 0x88FD, "GL_VERTEX_ATTRIB_ARRAY_INTEGER", }, { - 0x88FE, - "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE", + 0x88FE, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE", }, { - 0x88FF, - "GL_MAX_ARRAY_TEXTURE_LAYERS", + 0x88FF, "GL_MAX_ARRAY_TEXTURE_LAYERS", }, { - 0x8B6A, - "GL_FLOAT_MAT4x3_NV", + 0x8B6A, "GL_FLOAT_MAT4x3_NV", }, { - 0x93D0, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", + 0x93D0, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", }, { - 0x9143, - "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR", + 0x9143, "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR", }, { - 0x8DFD, - "GL_MAX_FRAGMENT_UNIFORM_VECTORS", + 0x8DFD, "GL_MAX_FRAGMENT_UNIFORM_VECTORS", }, { - 0x9145, - "GL_DEBUG_LOGGED_MESSAGES_KHR", + 0x9145, "GL_DEBUG_LOGGED_MESSAGES_KHR", }, { - 0x9146, - "GL_DEBUG_SEVERITY_HIGH_KHR", + 0x9146, "GL_DEBUG_SEVERITY_HIGH_KHR", }, { - 0x9147, - "GL_DEBUG_SEVERITY_MEDIUM_KHR", + 0x9147, "GL_DEBUG_SEVERITY_MEDIUM_KHR", }, { - 0x9148, - "GL_DEBUG_SEVERITY_LOW_KHR", + 0x9148, "GL_DEBUG_SEVERITY_LOW_KHR", }, { - 0x8F63, - "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT", + 0x8F63, "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT", }, { - 0x8F60, - "GL_MALI_SHADER_BINARY_ARM", + 0x8F60, "GL_MALI_SHADER_BINARY_ARM", }, { - 0x8F61, - "GL_MALI_PROGRAM_BINARY_ARM", + 0x8F61, "GL_MALI_PROGRAM_BINARY_ARM", }, { - 0x8F66, - "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM", + 0x8F66, "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM", }, { - 0x8F67, - "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT", + 0x8F67, "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT", }, { - 0x8F64, - "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT", + 0x8F64, "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT", }, { - 0x8F65, - "GL_FETCH_PER_SAMPLE_ARM", + 0x8F65, "GL_FETCH_PER_SAMPLE_ARM", }, { - 0x92D3, - "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT", + 0x92D3, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT", }, { - 0x87EE, - "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD", + 0x87EE, "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD", }, { - 0x822B, - "GL_RG8_EXT", + 0x822B, "GL_RG8_EXT", }, { - 0x822F, - "GL_RG16F_EXT", + 0x822F, "GL_RG16F_EXT", }, { - 0x822D, - "GL_R16F_EXT", + 0x822D, "GL_R16F_EXT", }, { - 0x822E, - "GL_R32F_EXT", + 0x822E, "GL_R32F_EXT", }, { - 1, - "GL_ES_VERSION_2_0", + 1, "GL_ES_VERSION_2_0", }, { - 0x84F9, - "GL_DEPTH_STENCIL_OES", + 0x84F9, "GL_DEPTH_STENCIL_OES", }, { - 0x82DB, - "GL_TEXTURE_VIEW_MIN_LEVEL_EXT", + 0x82DB, "GL_TEXTURE_VIEW_MIN_LEVEL_EXT", }, { - 0x8368, - "GL_UNSIGNED_INT_2_10_10_10_REV_EXT", + 0x8368, "GL_UNSIGNED_INT_2_10_10_10_REV_EXT", }, { - 0x8819, - "GL_LUMINANCE_ALPHA32F_EXT", + 0x8819, "GL_LUMINANCE_ALPHA32F_EXT", }, { - 0x8818, - "GL_LUMINANCE32F_EXT", + 0x8818, "GL_LUMINANCE32F_EXT", }, { - 0x82DF, - "GL_TEXTURE_IMMUTABLE_LEVELS", + 0x82DF, "GL_TEXTURE_IMMUTABLE_LEVELS", }, { - 0x8363, - "GL_UNSIGNED_SHORT_5_6_5", + 0x8363, "GL_UNSIGNED_SHORT_5_6_5", }, { - 0x9051, - "GL_IMAGE_BUFFER_EXT", + 0x9051, "GL_IMAGE_BUFFER_EXT", }, { - 0x84F2, - "GL_ALL_COMPLETED_NV", + 0x84F2, "GL_ALL_COMPLETED_NV", }, { - 0x8E5A, - "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT", + 0x8E5A, "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT", }, { - 0x84F4, - "GL_FENCE_CONDITION_NV", + 0x84F4, "GL_FENCE_CONDITION_NV", }, { - 0x8366, - "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT", + 0x8366, "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT", }, { - 0x8365, - "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT", + 0x8365, "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT", }, { - 0x84F7, - "GL_COMMANDS_COMPLETED_CHROMIUM", + 0x84F7, "GL_COMMANDS_COMPLETED_CHROMIUM", }, { - 0x8F9C, - "GL_SIGNED_NORMALIZED", + 0x8F9C, "GL_SIGNED_NORMALIZED", }, { - 0x92D5, - "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT", + 0x92D5, "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT", }, { - 0x881E, - "GL_LUMINANCE16F_EXT", + 0x881E, "GL_LUMINANCE16F_EXT", }, { - 0x84FA, - "GL_UNSIGNED_INT_24_8_OES", + 0x84FA, "GL_UNSIGNED_INT_24_8_OES", }, { - 0x92D4, - "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT", + 0x92D4, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT", }, { - 0x881A, - "GL_RGBA16F_EXT", + 0x881A, "GL_RGBA16F_EXT", }, { - 0x84FE, - "GL_TEXTURE_MAX_ANISOTROPY_EXT", + 0x84FE, "GL_TEXTURE_MAX_ANISOTROPY_EXT", }, { - 0x0901, - "GL_CCW", + 0x0901, "GL_CCW", }, { - 0x0900, - "GL_CW", + 0x0900, "GL_CW", }, { - 0x9317, - "GL_MAX_FRAMEBUFFER_LAYERS_EXT", + 0x9317, "GL_MAX_FRAMEBUFFER_LAYERS_EXT", }, { - 0x8229, - "GL_R8_EXT", + 0x8229, "GL_R8_EXT", }, { - 0x8230, - "GL_RG32F_EXT", + 0x8230, "GL_RG32F_EXT", }, { - 0x9312, - "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT", + 0x9312, "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT", }, { - 0x9283, - "GL_DISJOINT_NV", + 0x9283, "GL_DISJOINT_NV", }, { - 0x8221, - "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED", + 0x8221, "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED", }, { - 0x8227, - "GL_RG_EXT", + 0x8227, "GL_RG_EXT", }, { - 0x8B66, - "GL_FLOAT_MAT2x4_NV", + 0x8B66, "GL_FLOAT_MAT2x4_NV", }, { - 0x8B67, - "GL_FLOAT_MAT3x2_NV", + 0x8B67, "GL_FLOAT_MAT3x2_NV", }, { - 0x8E1E, - "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", + 0x8E1E, "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", }, { - 0x8B62, - "GL_SAMPLER_2D_SHADOW_EXT", + 0x8B62, "GL_SAMPLER_2D_SHADOW_EXT", }, { - 0x8B63, - "GL_SAMPLER_2D_RECT_ARB", + 0x8B63, "GL_SAMPLER_2D_RECT_ARB", }, { - 0x8B60, - "GL_SAMPLER_CUBE", + 0x8B60, "GL_SAMPLER_CUBE", }, { - 0x00001000, - "GL_DEPTH_BUFFER_BIT4_QCOM", + 0x00001000, "GL_DEPTH_BUFFER_BIT4_QCOM", }, { - 0x8B68, - "GL_FLOAT_MAT3x4_NV", + 0x8B68, "GL_FLOAT_MAT3x4_NV", }, { - 0x83F0, - "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", + 0x83F0, "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", }, { - 0x8D6A, - "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT", + 0x8D6A, "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT", }, { - 0x00000080, - "GL_COLOR_BUFFER_BIT7_QCOM", + 0x00000080, "GL_COLOR_BUFFER_BIT7_QCOM", }, { - 0x88F0, - "GL_DEPTH24_STENCIL8_OES", + 0x88F0, "GL_DEPTH24_STENCIL8_OES", }, { - 0x8E1F, - "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", + 0x8E1F, "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", }, { - 0x80A0, - "GL_SAMPLE_COVERAGE", + 0x80A0, "GL_SAMPLE_COVERAGE", }, { - 0x928F, - "GL_DST_ATOP_NV", + 0x928F, "GL_DST_ATOP_NV", }, { - 0x8213, - "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", + 0x8213, "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", }, { - 0x80A9, - "GL_SAMPLES", + 0x80A9, "GL_SAMPLES", }, { - 0x80A8, - "GL_SAMPLE_BUFFERS", + 0x80A8, "GL_SAMPLE_BUFFERS", }, { - 0x0D55, - "GL_ALPHA_BITS", + 0x0D55, "GL_ALPHA_BITS", }, { - 0x0D54, - "GL_BLUE_BITS", + 0x0D54, "GL_BLUE_BITS", }, { - 0x0D57, - "GL_STENCIL_BITS", + 0x0D57, "GL_STENCIL_BITS", }, { - 0x0D56, - "GL_DEPTH_BITS", + 0x0D56, "GL_DEPTH_BITS", }, { - 0x8CD5, - "GL_FRAMEBUFFER_COMPLETE", + 0x8CD5, "GL_FRAMEBUFFER_COMPLETE", }, { - 0x0D50, - "GL_SUBPIXEL_BITS", + 0x0D50, "GL_SUBPIXEL_BITS", }, { - 0x0D53, - "GL_GREEN_BITS", + 0x0D53, "GL_GREEN_BITS", }, { - 0x0D52, - "GL_RED_BITS", + 0x0D52, "GL_RED_BITS", }, { - 0x8037, - "GL_POLYGON_OFFSET_FILL", + 0x8037, "GL_POLYGON_OFFSET_FILL", }, { - 0x928C, - "GL_SRC_OUT_NV", + 0x928C, "GL_SRC_OUT_NV", }, { - 0x8034, - "GL_UNSIGNED_SHORT_5_5_5_1", + 0x8034, "GL_UNSIGNED_SHORT_5_5_5_1", }, { - 0x8033, - "GL_UNSIGNED_SHORT_4_4_4_4", + 0x8033, "GL_UNSIGNED_SHORT_4_4_4_4", }, { - 0x928B, - "GL_DST_IN_NV", + 0x928B, "GL_DST_IN_NV", }, { - 0x0305, - "GL_ONE_MINUS_DST_ALPHA", + 0x0305, "GL_ONE_MINUS_DST_ALPHA", }, { - 0x0304, - "GL_DST_ALPHA", + 0x0304, "GL_DST_ALPHA", }, { - 0x0307, - "GL_ONE_MINUS_DST_COLOR", + 0x0307, "GL_ONE_MINUS_DST_COLOR", }, { - 0x0306, - "GL_DST_COLOR", + 0x0306, "GL_DST_COLOR", }, { - 0x0301, - "GL_ONE_MINUS_SRC_COLOR", + 0x0301, "GL_ONE_MINUS_SRC_COLOR", }, { - 0x0300, - "GL_SRC_COLOR", + 0x0300, "GL_SRC_COLOR", }, { - 0x0303, - "GL_ONE_MINUS_SRC_ALPHA", + 0x0303, "GL_ONE_MINUS_SRC_ALPHA", }, { - 0x0302, - "GL_SRC_ALPHA", + 0x0302, "GL_SRC_ALPHA", }, { - 0x8212, - "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE", + 0x8212, "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE", }, { - 0x0308, - "GL_SRC_ALPHA_SATURATE", + 0x0308, "GL_SRC_ALPHA_SATURATE", }, { - 0x2A00, - "GL_POLYGON_OFFSET_UNITS", + 0x2A00, "GL_POLYGON_OFFSET_UNITS", }, { - 0xFFFFFFFF, - "GL_ALL_SHADER_BITS_EXT", + 0xFFFFFFFF, "GL_ALL_SHADER_BITS_EXT", }, { - 0x82DC, - "GL_TEXTURE_VIEW_NUM_LEVELS_EXT", + 0x82DC, "GL_TEXTURE_VIEW_NUM_LEVELS_EXT", }, { - 0x8C29, - "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT", + 0x8C29, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT", }, { - 0x82DD, - "GL_TEXTURE_VIEW_MIN_LAYER_EXT", + 0x82DD, "GL_TEXTURE_VIEW_MIN_LAYER_EXT", }, { - 0x00800000, - "GL_STENCIL_BUFFER_BIT7_QCOM", + 0x00800000, "GL_STENCIL_BUFFER_BIT7_QCOM", }, { - 0x82DE, - "GL_TEXTURE_VIEW_NUM_LAYERS_EXT", + 0x82DE, "GL_TEXTURE_VIEW_NUM_LAYERS_EXT", }, { - 0x00020000, - "GL_STENCIL_BUFFER_BIT1_QCOM", + 0x00020000, "GL_STENCIL_BUFFER_BIT1_QCOM", }, { - 0x8D00, - "GL_DEPTH_ATTACHMENT", + 0x8D00, "GL_DEPTH_ATTACHMENT", }, { - 0x8FA0, - "GL_PERFMON_GLOBAL_MODE_QCOM", + 0x8FA0, "GL_PERFMON_GLOBAL_MODE_QCOM", }, { - 0x8815, - "GL_RGB32F_EXT", + 0x8815, "GL_RGB32F_EXT", }, { - 0x8A35, - "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH", + 0x8A35, "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH", }, { - 0x8814, - "GL_RGBA32F_EXT", + 0x8814, "GL_RGBA32F_EXT", }, { - 0x9277, - "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", + 0x9277, "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", }, { - 0x6004, - "GL_COMMANDS_ISSUED_CHROMIUM", + 0x6004, "GL_COMMANDS_ISSUED_CHROMIUM", }, { - 0x813D, - "GL_TEXTURE_MAX_LEVEL_APPLE", + 0x813D, "GL_TEXTURE_MAX_LEVEL_APPLE", }, { - 0x8816, - "GL_ALPHA32F_EXT", + 0x8816, "GL_ALPHA32F_EXT", }, { - 0x813B, - "GL_TEXTURE_MAX_LOD", + 0x813B, "GL_TEXTURE_MAX_LOD", }, { - 0x8CDD, - "GL_FRAMEBUFFER_UNSUPPORTED", + 0x8CDD, "GL_FRAMEBUFFER_UNSUPPORTED", }, { - 0x8CDF, - "GL_MAX_COLOR_ATTACHMENTS_EXT", + 0x8CDF, "GL_MAX_COLOR_ATTACHMENTS_EXT", }, { - 0x90F3, - "GL_CONTEXT_ROBUST_ACCESS_KHR", + 0x90F3, "GL_CONTEXT_ROBUST_ACCESS_KHR", }, { - 0x90F2, - "GL_MAX_MULTIVIEW_BUFFERS_EXT", + 0x90F2, "GL_MAX_MULTIVIEW_BUFFERS_EXT", }, { - 0x90F1, - "GL_MULTIVIEW_EXT", + 0x90F1, "GL_MULTIVIEW_EXT", }, { - 0x90F0, - "GL_COLOR_ATTACHMENT_EXT", + 0x90F0, "GL_COLOR_ATTACHMENT_EXT", }, { - 0x803C, - "GL_ALPHA8_OES", + 0x803C, "GL_ALPHA8_OES", }, { - 0x8904, - "GL_MIN_PROGRAM_TEXEL_OFFSET", + 0x8904, "GL_MIN_PROGRAM_TEXEL_OFFSET", }, { - 0x84F5, - "GL_TEXTURE_RECTANGLE_ARB", + 0x84F5, "GL_TEXTURE_RECTANGLE_ARB", }, { - 0x882A, - "GL_DRAW_BUFFER5_EXT", + 0x882A, "GL_DRAW_BUFFER5_EXT", }, { - 0x8E7F, - "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", + 0x8E7F, "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", }, { - 0x80AA, - "GL_SAMPLE_COVERAGE_VALUE", + 0x80AA, "GL_SAMPLE_COVERAGE_VALUE", }, { - 0x84F6, - "GL_TEXTURE_BINDING_RECTANGLE_ARB", + 0x84F6, "GL_TEXTURE_BINDING_RECTANGLE_ARB", }, { - 0x80AB, - "GL_SAMPLE_COVERAGE_INVERT", + 0x80AB, "GL_SAMPLE_COVERAGE_INVERT", }, { - 0x8E7D, - "GL_MAX_PATCH_VERTICES_EXT", + 0x8E7D, "GL_MAX_PATCH_VERTICES_EXT", }, { - 0x6005, - "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM", + 0x6005, "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM", }, { - 0x9105, - "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES", + 0x9105, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES", }, { - 0x8E7E, - "GL_MAX_TESS_GEN_LEVEL_EXT", + 0x8E7E, "GL_MAX_TESS_GEN_LEVEL_EXT", }, { - 0x9102, - "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES", + 0x9102, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES", }, { - 0x8C40, - "GL_SRGB_EXT", + 0x8C40, "GL_SRGB_EXT", }, { - 0x8236, - "GL_R32UI", + 0x8236, "GL_R32UI", }, { - 0x8E7B, - "GL_FRACTIONAL_ODD_EXT", + 0x8E7B, "GL_FRACTIONAL_ODD_EXT", }, { - 0x00000040, - "GL_COLOR_BUFFER_BIT6_QCOM", + 0x00000040, "GL_COLOR_BUFFER_BIT6_QCOM", }, { - 0x882B, - "GL_DRAW_BUFFER6_EXT", + 0x882B, "GL_DRAW_BUFFER6_EXT", }, { - 0x8E7C, - "GL_FRACTIONAL_EVEN_EXT", + 0x8E7C, "GL_FRACTIONAL_EVEN_EXT", }, { - 0x8C8E, - "GL_TRANSFORM_FEEDBACK_BUFFER", + 0x8C8E, "GL_TRANSFORM_FEEDBACK_BUFFER", }, { - 0x8C8D, - "GL_SEPARATE_ATTRIBS", + 0x8C8D, "GL_SEPARATE_ATTRIBS", }, { - 0x8C8F, - "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING", + 0x8C8F, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING", }, { - 0x8C8A, - "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", + 0x8C8A, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", }, { - 0x8C8C, - "GL_INTERLEAVED_ATTRIBS", + 0x8C8C, "GL_INTERLEAVED_ATTRIBS", }, { - 0x8C8B, - "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", + 0x8C8B, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", }, { - 0x8C17, - "GL_UNSIGNED_NORMALIZED_EXT", + 0x8C17, "GL_UNSIGNED_NORMALIZED_EXT", }, { - 0x8A3E, - "GL_UNIFORM_IS_ROW_MAJOR", + 0x8A3E, "GL_UNIFORM_IS_ROW_MAJOR", }, { - 0x8E7A, - "GL_ISOLINES_EXT", + 0x8E7A, "GL_ISOLINES_EXT", }, { - 0x6006, - "GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM", + 0x6006, "GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM", }, { - 0x8D99, - "GL_RGBA_INTEGER", + 0x8D99, "GL_RGBA_INTEGER", }, { - 0x8D98, - "GL_RGB_INTEGER", + 0x8D98, "GL_RGB_INTEGER", }, { - 0x8A4A, - "GL_SKIP_DECODE_EXT", + 0x8A4A, "GL_SKIP_DECODE_EXT", }, { - 0x8A4F, - "GL_PROGRAM_PIPELINE_OBJECT_EXT", + 0x8A4F, "GL_PROGRAM_PIPELINE_OBJECT_EXT", }, { - 0x882C, - "GL_DRAW_BUFFER7_EXT", + 0x882C, "GL_DRAW_BUFFER7_EXT", }, { - 0x0010, - "GL_MAP_FLUSH_EXPLICIT_BIT_EXT", + 0x0010, "GL_MAP_FLUSH_EXPLICIT_BIT_EXT", }, { - 0x8918, - "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT", + 0x8918, "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT", }, { - 0x8919, - "GL_SAMPLER_BINDING", + 0x8919, "GL_SAMPLER_BINDING", }, { - 0x92CD, - "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT", + 0x92CD, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT", }, { - 0x92CE, - "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT", + 0x92CE, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT", }, { - 0x8C85, - "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE", + 0x8C85, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE", }, { - 0x8D7C, - "GL_RGBA8UI", + 0x8D7C, "GL_RGBA8UI", }, { - 0x6007, - "GL_LATENCY_QUERY_CHROMIUM", + 0x6007, "GL_LATENCY_QUERY_CHROMIUM", }, { - 0x8D83, - "GL_RGB32I", + 0x8D83, "GL_RGB32I", }, { - 0x8916, - "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT", + 0x8916, "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT", }, { - 0x8917, - "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT", + 0x8917, "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT", }, { - 0x881F, - "GL_LUMINANCE_ALPHA16F_EXT", + 0x881F, "GL_LUMINANCE_ALPHA16F_EXT", }, { - 0x84FD, - "GL_MAX_TEXTURE_LOD_BIAS", + 0x84FD, "GL_MAX_TEXTURE_LOD_BIAS", }, { - 0x882D, - "GL_DRAW_BUFFER8_EXT", + 0x882D, "GL_DRAW_BUFFER8_EXT", }, { - 0x0BA6, - "GL_PATH_MODELVIEW_MATRIX_CHROMIUM", + 0x0BA6, "GL_PATH_MODELVIEW_MATRIX_CHROMIUM", }, { - 0x8A42, - "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS", + 0x8A42, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS", }, { - 0x8F37, - "GL_COPY_WRITE_BUFFER_NV", + 0x8F37, "GL_COPY_WRITE_BUFFER_NV", }, { - 0x8F36, - "GL_COPY_READ_BUFFER_NV", + 0x8F36, "GL_COPY_READ_BUFFER_NV", }, { - 0x84FF, - "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", + 0x84FF, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", }, { - 0x8A3C, - "GL_UNIFORM_ARRAY_STRIDE", + 0x8A3C, "GL_UNIFORM_ARRAY_STRIDE", }, { - 0x8A44, - "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", + 0x8A44, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", }, { - 0x6000, - "GL_TEXTURE_POOL_CHROMIUM", + 0x6000, "GL_TEXTURE_POOL_CHROMIUM", }, { - 0x0B74, - "GL_DEPTH_FUNC", + 0x0B74, "GL_DEPTH_FUNC", }, { - 0x8A49, - "GL_DECODE_EXT", + 0x8A49, "GL_DECODE_EXT", }, { - 0x881B, - "GL_RGB16F_EXT", + 0x881B, "GL_RGB16F_EXT", }, { - 0x0B71, - "GL_DEPTH_TEST", + 0x0B71, "GL_DEPTH_TEST", }, { - 0x0B70, - "GL_DEPTH_RANGE", + 0x0B70, "GL_DEPTH_RANGE", }, { - 0x0B73, - "GL_DEPTH_CLEAR_VALUE", + 0x0B73, "GL_DEPTH_CLEAR_VALUE", }, { - 0x0B72, - "GL_DEPTH_WRITEMASK", + 0x0B72, "GL_DEPTH_WRITEMASK", }, { - 0x8BD5, - "GL_TEXTURE_INTERNAL_FORMAT_QCOM", + 0x8BD5, "GL_TEXTURE_INTERNAL_FORMAT_QCOM", }, { - 0x85BA, - "GL_UNSIGNED_SHORT_8_8_APPLE", + 0x85BA, "GL_UNSIGNED_SHORT_8_8_APPLE", }, { - 0x8C87, - "GL_PRIMITIVES_GENERATED_EXT", + 0x8C87, "GL_PRIMITIVES_GENERATED_EXT", }, { - 0x8C80, - "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", + 0x8C80, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", }, { - 0x8C83, - "GL_TRANSFORM_FEEDBACK_VARYINGS", + 0x8C83, "GL_TRANSFORM_FEEDBACK_VARYINGS", }, { - 0x8D69, - "GL_PRIMITIVE_RESTART_FIXED_INDEX", + 0x8D69, "GL_PRIMITIVE_RESTART_FIXED_INDEX", }, { - 0x882E, - "GL_DRAW_BUFFER9_EXT", + 0x882E, "GL_DRAW_BUFFER9_EXT", }, { - 0x8A32, - "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT", + 0x8A32, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT", }, { - 0x8A31, - "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", + 0x8A31, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", }, { - 0x8C89, - "GL_RASTERIZER_DISCARD", + 0x8C89, "GL_RASTERIZER_DISCARD", }, { - 0x8C88, - "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", + 0x8C88, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", }, { - 0x8C1A, - "GL_TEXTURE_2D_ARRAY", + 0x8C1A, "GL_TEXTURE_2D_ARRAY", }, { - 0x910D, - "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", + 0x910D, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", }, { - 0x8E80, - "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", + 0x8E80, "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", }, { - 0x910B, - "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", + 0x910B, "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", }, { - 0x910C, - "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", + 0x910C, "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", }, { - 0x94FA, - "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL", + 0x94FA, "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL", }, { - 0x8073, - "GL_MAX_3D_TEXTURE_SIZE_OES", + 0x8073, "GL_MAX_3D_TEXTURE_SIZE_OES", }, { - 0x8072, - "GL_TEXTURE_WRAP_R_OES", + 0x8072, "GL_TEXTURE_WRAP_R_OES", }, { - 0x9289, - "GL_DST_OVER_NV", + 0x9289, "GL_DST_OVER_NV", }, { - 0x882F, - "GL_DRAW_BUFFER10_EXT", + 0x882F, "GL_DRAW_BUFFER10_EXT", }, { - 0x8074, - "GL_VERTEX_ARRAY_KHR", + 0x8074, "GL_VERTEX_ARRAY_KHR", }, { - 0x80E1, - "GL_BGRA_EXT", + 0x80E1, "GL_BGRA_EXT", }, { - 0x8ED7, - "GL_COVERAGE_AUTOMATIC_NV", + 0x8ED7, "GL_COVERAGE_AUTOMATIC_NV", }, { - 0x8ED6, - "GL_COVERAGE_EDGE_FRAGMENTS_NV", + 0x8ED6, "GL_COVERAGE_EDGE_FRAGMENTS_NV", }, { - 0x8ED5, - "GL_COVERAGE_ALL_FRAGMENTS_NV", + 0x8ED5, "GL_COVERAGE_ALL_FRAGMENTS_NV", }, { - 0x8ED4, - "GL_COVERAGE_SAMPLES_NV", + 0x8ED4, "GL_COVERAGE_SAMPLES_NV", }, { - 0x8ED3, - "GL_COVERAGE_BUFFERS_NV", + 0x8ED3, "GL_COVERAGE_BUFFERS_NV", }, { - 0x8ED2, - "GL_COVERAGE_ATTACHMENT_NV", + 0x8ED2, "GL_COVERAGE_ATTACHMENT_NV", }, { - 0x8ED1, - "GL_COVERAGE_COMPONENT4_NV", + 0x8ED1, "GL_COVERAGE_COMPONENT4_NV", }, { - 0x8ED0, - "GL_COVERAGE_COMPONENT_NV", + 0x8ED0, "GL_COVERAGE_COMPONENT_NV", }, { - 0x8217, - "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", + 0x8217, "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", }, { - 0x8E89, - "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT", + 0x8E89, "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT", }, { - 0x8216, - "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", + 0x8216, "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", }, { - 0x8A36, - "GL_ACTIVE_UNIFORM_BLOCKS", + 0x8A36, "GL_ACTIVE_UNIFORM_BLOCKS", }, { - 0x8A37, - "GL_UNIFORM_TYPE", + 0x8A37, "GL_UNIFORM_TYPE", }, { - 0x8A34, - "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", + 0x8A34, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", }, { - 0x3006, - "GL_CLIP_DISTANCE6_APPLE", + 0x3006, "GL_CLIP_DISTANCE6_APPLE", }, { - 0x800B, - "GL_FUNC_REVERSE_SUBTRACT", + 0x800B, "GL_FUNC_REVERSE_SUBTRACT", }, { - 0x8A33, - "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", + 0x8A33, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", }, { - 0x00000400, - "GL_STENCIL_BUFFER_BIT", + 0x00000400, "GL_STENCIL_BUFFER_BIT", }, { - 0x800A, - "GL_FUNC_SUBTRACT", + 0x800A, "GL_FUNC_SUBTRACT", }, { - 0x8214, - "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", + 0x8214, "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", }, { - 0x8A38, - "GL_UNIFORM_SIZE", + 0x8A38, "GL_UNIFORM_SIZE", }, { - 0x8A39, - "GL_UNIFORM_NAME_LENGTH", + 0x8A39, "GL_UNIFORM_NAME_LENGTH", }, { - 0x8E2C, - "GL_DEPTH_COMPONENT16_NONLINEAR_NV", + 0x8E2C, "GL_DEPTH_COMPONENT16_NONLINEAR_NV", }, { - 0x889F, - "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", + 0x889F, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", }, { - 0x8219, - "GL_FRAMEBUFFER_UNDEFINED_OES", + 0x8219, "GL_FRAMEBUFFER_UNDEFINED_OES", }, { - 0x8E23, - "GL_TRANSFORM_FEEDBACK_PAUSED", + 0x8E23, "GL_TRANSFORM_FEEDBACK_PAUSED", }, { - 0x8E22, - "GL_TRANSFORM_FEEDBACK", + 0x8E22, "GL_TRANSFORM_FEEDBACK", }, { - 0x8E25, - "GL_TRANSFORM_FEEDBACK_BINDING", + 0x8E25, "GL_TRANSFORM_FEEDBACK_BINDING", }, { - 0x9054, - "GL_IMAGE_CUBE_MAP_ARRAY_EXT", + 0x9054, "GL_IMAGE_CUBE_MAP_ARRAY_EXT", }, { - 0x8E28, - "GL_TIMESTAMP_EXT", + 0x8E28, "GL_TIMESTAMP_EXT", }, { - 0x8006, - "GL_FUNC_ADD", + 0x8006, "GL_FUNC_ADD", }, { - 0x8007, - "GL_MIN_EXT", + 0x8007, "GL_MIN_EXT", }, { - 0x8004, - "GL_ONE_MINUS_CONSTANT_ALPHA", + 0x8004, "GL_ONE_MINUS_CONSTANT_ALPHA", }, { - 0x8005, - "GL_BLEND_COLOR", + 0x8005, "GL_BLEND_COLOR", }, { - 0x8002, - "GL_ONE_MINUS_CONSTANT_COLOR", + 0x8002, "GL_ONE_MINUS_CONSTANT_COLOR", }, { - 0x8003, - "GL_CONSTANT_ALPHA", + 0x8003, "GL_CONSTANT_ALPHA", }, { - 0x8001, - "GL_CONSTANT_COLOR", + 0x8001, "GL_CONSTANT_COLOR", }, { - 0x0204, - "GL_GREATER", + 0x0204, "GL_GREATER", }, { - 0x0205, - "GL_NOTEQUAL", + 0x0205, "GL_NOTEQUAL", }, { - 0x0206, - "GL_GEQUAL", + 0x0206, "GL_GEQUAL", }, { - 0x0207, - "GL_ALWAYS", + 0x0207, "GL_ALWAYS", }, { - 0x0200, - "GL_NEVER", + 0x0200, "GL_NEVER", }, { - 0x0201, - "GL_LESS", + 0x0201, "GL_LESS", }, { - 0x0202, - "GL_EQUAL", + 0x0202, "GL_EQUAL", }, { - 0x0203, - "GL_LEQUAL", + 0x0203, "GL_LEQUAL", }, { - 0x8BD6, - "GL_TEXTURE_FORMAT_QCOM", + 0x8BD6, "GL_TEXTURE_FORMAT_QCOM", }, { - 0x8228, - "GL_RG_INTEGER", + 0x8228, "GL_RG_INTEGER", }, { - 0x2901, - "GL_REPEAT", + 0x2901, "GL_REPEAT", }, { - 0x9067, - "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT", + 0x9067, "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT", }, { - 0x92A0, - "GL_EXCLUSION_KHR", + 0x92A0, "GL_EXCLUSION_KHR", }, { - 0x93D8, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", + 0x93D8, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", }, { - 0x93D9, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", + 0x93D9, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", }, { - 0x8FB2, - "GL_GPU_OPTIMIZED_QCOM", + 0x8FB2, "GL_GPU_OPTIMIZED_QCOM", }, { - 0x190A, - "GL_LUMINANCE_ALPHA", + 0x190A, "GL_LUMINANCE_ALPHA", }, { - 0x8FB0, - "GL_BINNING_CONTROL_HINT_QCOM", + 0x8FB0, "GL_BINNING_CONTROL_HINT_QCOM", }, { - 0x905C, - "GL_INT_IMAGE_BUFFER_EXT", + 0x905C, "GL_INT_IMAGE_BUFFER_EXT", }, { - 0x1E00, - "GL_KEEP", + 0x1E00, "GL_KEEP", }, { - 0x1E01, - "GL_REPLACE", + 0x1E01, "GL_REPLACE", }, { - 0x1E02, - "GL_INCR", + 0x1E02, "GL_INCR", }, { - 0x1E03, - "GL_DECR", + 0x1E03, "GL_DECR", }, { - 0x93D6, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", + 0x93D6, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", }, { - 0x93D7, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", + 0x93D7, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", }, { - 0x93D4, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", + 0x93D4, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", }, { - 0x93D5, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", + 0x93D5, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", }, { - 0x886D, - "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT", + 0x886D, "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT", }, { - 0x0BE2, - "GL_BLEND", + 0x0BE2, "GL_BLEND", }, { - 0x84CB, - "GL_TEXTURE11", + 0x84CB, "GL_TEXTURE11", }, { - 0x8D55, - "GL_RENDERBUFFER_STENCIL_SIZE", + 0x8D55, "GL_RENDERBUFFER_STENCIL_SIZE", }, { - 0x8D54, - "GL_RENDERBUFFER_DEPTH_SIZE", + 0x8D54, "GL_RENDERBUFFER_DEPTH_SIZE", }, { - 0x8D57, - "GL_MAX_SAMPLES_ANGLE", + 0x8D57, "GL_MAX_SAMPLES_ANGLE", }, { - 0x8D56, - "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE", + 0x8D56, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE", }, { - 0x8D51, - "GL_RENDERBUFFER_GREEN_SIZE", + 0x8D51, "GL_RENDERBUFFER_GREEN_SIZE", }, { - 0x8D50, - "GL_RENDERBUFFER_RED_SIZE", + 0x8D50, "GL_RENDERBUFFER_RED_SIZE", }, { - 0x8D53, - "GL_RENDERBUFFER_ALPHA_SIZE", + 0x8D53, "GL_RENDERBUFFER_ALPHA_SIZE", }, { - 0x8D52, - "GL_RENDERBUFFER_BLUE_SIZE", + 0x8D52, "GL_RENDERBUFFER_BLUE_SIZE", }, { - 0x92A6, - "GL_VIVIDLIGHT_NV", + 0x92A6, "GL_VIVIDLIGHT_NV", }, { - 0x8A2A, - "GL_UNIFORM_BUFFER_SIZE", + 0x8A2A, "GL_UNIFORM_BUFFER_SIZE", }, { - 0x8DCC, - "GL_INT_SAMPLER_CUBE", + 0x8DCC, "GL_INT_SAMPLER_CUBE", }, { - 0x78F1, - "GL_MAP_CHROMIUM", + 0x78F1, "GL_MAP_CHROMIUM", }, { - 0x00080000, - "GL_STENCIL_BUFFER_BIT3_QCOM", + 0x00080000, "GL_STENCIL_BUFFER_BIT3_QCOM", }, { - 0x92A7, - "GL_LINEARLIGHT_NV", + 0x92A7, "GL_LINEARLIGHT_NV", }, { - 0x8DCF, - "GL_INT_SAMPLER_2D_ARRAY", + 0x8DCF, "GL_INT_SAMPLER_2D_ARRAY", }, { - 0x886A, - "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED", + 0x886A, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED", }, { - 0x8C41, - "GL_SRGB8_NV", + 0x8C41, "GL_SRGB8_NV", }, { - 0x0C01, - "GL_DRAW_BUFFER_EXT", + 0x0C01, "GL_DRAW_BUFFER_EXT", }, { - 0x886C, - "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT", + 0x886C, "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT", }, { - 0x90CB, - "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT", + 0x90CB, "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT", }, { - 0x8DCA, - "GL_INT_SAMPLER_2D", + 0x8DCA, "GL_INT_SAMPLER_2D", }, { - 0x93C7, - "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES", + 0x93C7, "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES", }, { - 0x8B5F, - "GL_SAMPLER_3D_OES", + 0x8B5F, "GL_SAMPLER_3D_OES", }, { - 0x8B95, - "GL_PALETTE8_RGB8_OES", + 0x8B95, "GL_PALETTE8_RGB8_OES", }, { - 0x9250, - "GL_SHADER_BINARY_DMP", + 0x9250, "GL_SHADER_BINARY_DMP", }, { - 0x9251, - "GL_SMAPHS30_PROGRAM_BINARY_DMP", + 0x9251, "GL_SMAPHS30_PROGRAM_BINARY_DMP", }, { - 0x9252, - "GL_SMAPHS_PROGRAM_BINARY_DMP", + 0x9252, "GL_SMAPHS_PROGRAM_BINARY_DMP", }, { - 0x9253, - "GL_DMP_PROGRAM_BINARY_DMP", + 0x9253, "GL_DMP_PROGRAM_BINARY_DMP", }, { - 0x8DC8, - "GL_UNSIGNED_INT_VEC4", + 0x8DC8, "GL_UNSIGNED_INT_VEC4", }, { - 0x3000, - "GL_CLIP_DISTANCE0_APPLE", + 0x3000, "GL_CLIP_DISTANCE0_APPLE", }, { - 0x8C92, - "GL_ATC_RGB_AMD", + 0x8C92, "GL_ATC_RGB_AMD", }, { - 0x8DC1, - "GL_SAMPLER_2D_ARRAY", + 0x8DC1, "GL_SAMPLER_2D_ARRAY", }, { - 0x9154, - "GL_VERTEX_ARRAY_OBJECT_EXT", + 0x9154, "GL_VERTEX_ARRAY_OBJECT_EXT", }, { - 0x9153, - "GL_QUERY_OBJECT_EXT", + 0x9153, "GL_QUERY_OBJECT_EXT", }, { - 0x8864, - "GL_QUERY_COUNTER_BITS_EXT", + 0x8864, "GL_QUERY_COUNTER_BITS_EXT", }, { - 0x9151, - "GL_BUFFER_OBJECT_EXT", + 0x9151, "GL_BUFFER_OBJECT_EXT", }, { - 0x8C93, - "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD", + 0x8C93, "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD", }, { - 0x00000002, - "GL_CONTEXT_FLAG_DEBUG_BIT_KHR", + 0x00000002, "GL_CONTEXT_FLAG_DEBUG_BIT_KHR", }, { - 0x8A3F, - "GL_UNIFORM_BLOCK_BINDING", + 0x8A3F, "GL_UNIFORM_BLOCK_BINDING", }, { - 0x00000000, - "GL_PERFQUERY_SINGLE_CONTEXT_INTEL", + 0x00000000, "GL_PERFQUERY_SINGLE_CONTEXT_INTEL", }, { - 0x00000001, - "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE", + 0x00000001, "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE", }, { - 0x9248, - "GL_OVERLAY_TRANSFORM_ROTATE_90_CHROMIUM", + 0x9248, "GL_OVERLAY_TRANSFORM_ROTATE_90_CHROMIUM", }, { - 0x00000004, - "GL_GEOMETRY_SHADER_BIT_EXT", + 0x00000004, "GL_GEOMETRY_SHADER_BIT_EXT", }, { - 0x1702, - "GL_TEXTURE", + 0x1702, "GL_TEXTURE", }, { - 0x3003, - "GL_CLIP_DISTANCE3_APPLE", + 0x3003, "GL_CLIP_DISTANCE3_APPLE", }, { - 0x00000008, - "GL_TESS_CONTROL_SHADER_BIT_EXT", + 0x00000008, "GL_TESS_CONTROL_SHADER_BIT_EXT", }, { - 0x8B58, - "GL_BOOL_VEC3", + 0x8B58, "GL_BOOL_VEC3", }, { - 0x8A3D, - "GL_UNIFORM_MATRIX_STRIDE", + 0x8A3D, "GL_UNIFORM_MATRIX_STRIDE", }, { - 0x8828, - "GL_DRAW_BUFFER3_EXT", + 0x8828, "GL_DRAW_BUFFER3_EXT", }, { - 0x8DF0, - "GL_LOW_FLOAT", + 0x8DF0, "GL_LOW_FLOAT", }, { - 0x1906, - "GL_ALPHA", + 0x1906, "GL_ALPHA", }, { - 0x1907, - "GL_RGB", + 0x1907, "GL_RGB", }, { - 0x8FBB, - "GL_GPU_DISJOINT_EXT", + 0x8FBB, "GL_GPU_DISJOINT_EXT", }, { - 0x1901, - "GL_STENCIL_INDEX_OES", + 0x1901, "GL_STENCIL_INDEX_OES", }, { - 0x1902, - "GL_DEPTH_COMPONENT", + 0x1902, "GL_DEPTH_COMPONENT", }, { - 0x8B56, - "GL_BOOL", + 0x8B56, "GL_BOOL", }, { - 0x93DB, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", + 0x93DB, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", }, { - 0x8B9B, - "GL_IMPLEMENTATION_COLOR_READ_FORMAT", + 0x8B9B, "GL_IMPLEMENTATION_COLOR_READ_FORMAT", }, { - 0x8B9A, - "GL_IMPLEMENTATION_COLOR_READ_TYPE", + 0x8B9A, "GL_IMPLEMENTATION_COLOR_READ_TYPE", }, { - 0x93DA, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", + 0x93DA, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", }, { - 0x1908, - "GL_RGBA", + 0x1908, "GL_RGBA", }, { - 0x8DF2, - "GL_HIGH_FLOAT", + 0x8DF2, "GL_HIGH_FLOAT", }, { - 0x93DD, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", + 0x93DD, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", }, { - 0x8827, - "GL_DRAW_BUFFER2_EXT", + 0x8827, "GL_DRAW_BUFFER2_EXT", }, { - 0x9243, - "GL_UNPACK_COLORSPACE_CONVERSION_CHROMIUM", + 0x9243, "GL_UNPACK_COLORSPACE_CONVERSION_CHROMIUM", }, { - 0x8DF3, - "GL_LOW_INT", + 0x8DF3, "GL_LOW_INT", }, { - 0x82E8, - "GL_MAX_LABEL_LENGTH_KHR", + 0x82E8, "GL_MAX_LABEL_LENGTH_KHR", }, { - 0x82E6, - "GL_SAMPLER_KHR", + 0x82E6, "GL_SAMPLER_KHR", }, { - 0x0C02, - "GL_READ_BUFFER_EXT", + 0x0C02, "GL_READ_BUFFER_EXT", }, { - 0x82E3, - "GL_QUERY_KHR", + 0x82E3, "GL_QUERY_KHR", }, { - 0x82E2, - "GL_PROGRAM_KHR", + 0x82E2, "GL_PROGRAM_KHR", }, { - 0x82E1, - "GL_SHADER_KHR", + 0x82E1, "GL_SHADER_KHR", }, { - 0x8B52, - "GL_FLOAT_VEC4", + 0x8B52, "GL_FLOAT_VEC4", }, { - 0x8239, - "GL_RG16I", + 0x8239, "GL_RG16I", }, { - 0x8238, - "GL_RG8UI", + 0x8238, "GL_RG8UI", }, { - 0x9240, - "GL_UNPACK_FLIP_Y_CHROMIUM", + 0x9240, "GL_UNPACK_FLIP_Y_CHROMIUM", }, { - 0x8DF6, - "GL_UNSIGNED_INT_10_10_10_2_OES", + 0x8DF6, "GL_UNSIGNED_INT_10_10_10_2_OES", }, { - 0x8A30, - "GL_MAX_UNIFORM_BLOCK_SIZE", + 0x8A30, "GL_MAX_UNIFORM_BLOCK_SIZE", }, { - 0x9273, - "GL_COMPRESSED_SIGNED_RG11_EAC", + 0x9273, "GL_COMPRESSED_SIGNED_RG11_EAC", }, { - 0x8231, - "GL_R8I", + 0x8231, "GL_R8I", }, { - 0x8866, - "GL_QUERY_RESULT_EXT", + 0x8866, "GL_QUERY_RESULT_EXT", }, { - 0x8233, - "GL_R16I", + 0x8233, "GL_R16I", }, { - 0x8DF7, - "GL_INT_10_10_10_2_OES", + 0x8DF7, "GL_INT_10_10_10_2_OES", }, { - 0x8235, - "GL_R32I", + 0x8235, "GL_R32I", }, { - 0x8234, - "GL_R16UI", + 0x8234, "GL_R16UI", }, { - 0x8237, - "GL_RG8I", + 0x8237, "GL_RG8I", }, { - 0x9246, - "GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM", + 0x9246, "GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM", }, { - 0x8B69, - "GL_FLOAT_MAT4x2_NV", + 0x8B69, "GL_FLOAT_MAT4x2_NV", }, { - 0x812D, - "GL_CLAMP_TO_BORDER_EXT", + 0x812D, "GL_CLAMP_TO_BORDER_EXT", }, { - 0x812F, - "GL_CLAMP_TO_EDGE", + 0x812F, "GL_CLAMP_TO_EDGE", }, { - 0x92A4, - "GL_LINEARDODGE_NV", + 0x92A4, "GL_LINEARDODGE_NV", }, { - 0x8DD8, - "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT", + 0x8DD8, "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT", }, { - 0x8DD9, - "GL_GEOMETRY_SHADER_EXT", + 0x8DD9, "GL_GEOMETRY_SHADER_EXT", }, { - 0x86A3, - "GL_COMPRESSED_TEXTURE_FORMATS", + 0x86A3, "GL_COMPRESSED_TEXTURE_FORMATS", }, { - 0x8DD4, - "GL_UNSIGNED_INT_SAMPLER_CUBE", + 0x8DD4, "GL_UNSIGNED_INT_SAMPLER_CUBE", }, { - 0x9244, - "GL_BIND_GENERATES_RESOURCE_CHROMIUM", + 0x9244, "GL_BIND_GENERATES_RESOURCE_CHROMIUM", }, { - 0x8DD2, - "GL_UNSIGNED_INT_SAMPLER_2D", + 0x8DD2, "GL_UNSIGNED_INT_SAMPLER_2D", }, { - 0x8DD3, - "GL_UNSIGNED_INT_SAMPLER_3D", + 0x8DD3, "GL_UNSIGNED_INT_SAMPLER_3D", }, { - 0x8DD0, - "GL_INT_SAMPLER_BUFFER_EXT", + 0x8DD0, "GL_INT_SAMPLER_BUFFER_EXT", }, { - 0x86A2, - "GL_NUM_COMPRESSED_TEXTURE_FORMATS", + 0x86A2, "GL_NUM_COMPRESSED_TEXTURE_FORMATS", }, { - 0x0CF3, - "GL_UNPACK_SKIP_ROWS_EXT", + 0x0CF3, "GL_UNPACK_SKIP_ROWS_EXT", }, { - 0x0CF2, - "GL_UNPACK_ROW_LENGTH_EXT", + 0x0CF2, "GL_UNPACK_ROW_LENGTH_EXT", }, { - 0x140C, - "GL_FIXED", + 0x140C, "GL_FIXED", }, { - 0x140B, - "GL_HALF_FLOAT", + 0x140B, "GL_HALF_FLOAT", }, { - 0x8008, - "GL_MAX_EXT", + 0x8008, "GL_MAX_EXT", }, { - 0x0CF5, - "GL_UNPACK_ALIGNMENT", + 0x0CF5, "GL_UNPACK_ALIGNMENT", }, { - 0x8867, - "GL_QUERY_RESULT_AVAILABLE_EXT", + 0x8867, "GL_QUERY_RESULT_AVAILABLE_EXT", }, { - 0x8D82, - "GL_RGBA32I", + 0x8D82, "GL_RGBA32I", }, { - 0x8009, - "GL_BLEND_EQUATION", + 0x8009, "GL_BLEND_EQUATION", }, { - 0x911F, - "GL_BUFFER_ACCESS_FLAGS", + 0x911F, "GL_BUFFER_ACCESS_FLAGS", }, { - 0x1401, - "GL_UNSIGNED_BYTE", + 0x1401, "GL_UNSIGNED_BYTE", }, { - 0x1400, - "GL_BYTE", + 0x1400, "GL_BYTE", }, { - 0x1403, - "GL_UNSIGNED_SHORT", + 0x1403, "GL_UNSIGNED_SHORT", }, { - 0x1402, - "GL_SHORT", + 0x1402, "GL_SHORT", }, { - 0x1405, - "GL_UNSIGNED_INT", + 0x1405, "GL_UNSIGNED_INT", }, { - 0x1404, - "GL_INT", + 0x1404, "GL_INT", }, { - 0x1406, - "GL_FLOAT", + 0x1406, "GL_FLOAT", }, { - 0x8C1D, - "GL_TEXTURE_BINDING_2D_ARRAY", + 0x8C1D, "GL_TEXTURE_BINDING_2D_ARRAY", }, { - 0x8DDF, - "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT", + 0x8DDF, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT", }, { - 0x8043, - "GL_LUMINANCE4_ALPHA4_OES", + 0x8043, "GL_LUMINANCE4_ALPHA4_OES", }, { - 0x8040, - "GL_LUMINANCE8_OES", + 0x8040, "GL_LUMINANCE8_OES", }, { - 0x8045, - "GL_LUMINANCE8_ALPHA8_OES", + 0x8045, "GL_LUMINANCE8_ALPHA8_OES", }, { - 0x8CD1, - "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", + 0x8CD1, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", }, { - 0x00040000, - "GL_STENCIL_BUFFER_BIT2_QCOM", + 0x00040000, "GL_STENCIL_BUFFER_BIT2_QCOM", }, { - 0x8CD0, - "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", + 0x8CD0, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", }, { - 0x823A, - "GL_RG16UI", + 0x823A, "GL_RG16UI", }, { - 0x8CE4, - "GL_COLOR_ATTACHMENT4_EXT", + 0x8CE4, "GL_COLOR_ATTACHMENT4_EXT", }, { - 0x823B, - "GL_RG32I", + 0x823B, "GL_RG32I", }, { - 0x8CD3, - "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", + 0x8CD3, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", }, { - 0x846E, - "GL_ALIASED_LINE_WIDTH_RANGE", + 0x846E, "GL_ALIASED_LINE_WIDTH_RANGE", }, { - 0x0B90, - "GL_STENCIL_TEST", + 0x0B90, "GL_STENCIL_TEST", }, { - 0x8CD2, - "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", + 0x8CD2, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", }, { - 0x881C, - "GL_ALPHA16F_EXT", + 0x881C, "GL_ALPHA16F_EXT", }, { - 0x928E, - "GL_SRC_ATOP_NV", + 0x928E, "GL_SRC_ATOP_NV", }, { - 0x8CD4, - "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES", + 0x8CD4, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES", }, { - 0x9113, - "GL_SYNC_CONDITION_APPLE", + 0x9113, "GL_SYNC_CONDITION_APPLE", }, { - 0x8CD7, - "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", + 0x8CD7, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", }, { - 0x08000000, - "GL_MULTISAMPLE_BUFFER_BIT3_QCOM", + 0x08000000, "GL_MULTISAMPLE_BUFFER_BIT3_QCOM", }, { - 0x93A4, - "GL_PACK_REVERSE_ROW_ORDER_ANGLE", + 0x93A4, "GL_PACK_REVERSE_ROW_ORDER_ANGLE", }, { - 0x8038, - "GL_POLYGON_OFFSET_FACTOR", + 0x8038, "GL_POLYGON_OFFSET_FACTOR", }, { - 0x94F9, - "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL", + 0x94F9, "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL", }, { - 0x851A, - "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z", + 0x851A, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z", }, { - 0x851C, - "GL_MAX_CUBE_MAP_TEXTURE_SIZE", + 0x851C, "GL_MAX_CUBE_MAP_TEXTURE_SIZE", }, { - 0x8CD9, - "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS", + 0x8CD9, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS", }, { - 0x84CC, - "GL_TEXTURE12", + 0x84CC, "GL_TEXTURE12", }, { - 0x0BA2, - "GL_VIEWPORT", + 0x0BA2, "GL_VIEWPORT", }, { - 0x84CA, - "GL_TEXTURE10", + 0x84CA, "GL_TEXTURE10", }, { - 0x0BA7, - "GL_PATH_PROJECTION_MATRIX_CHROMIUM", + 0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM", }, { - 0x84CF, - "GL_TEXTURE15", + 0x84CF, "GL_TEXTURE15", }, { - 0x84CE, - "GL_TEXTURE14", + 0x84CE, "GL_TEXTURE14", }, { - 0x84CD, - "GL_TEXTURE13", + 0x84CD, "GL_TEXTURE13", }, { - 0x83F9, - "GL_PERFQUERY_DONOT_FLUSH_INTEL", + 0x83F9, "GL_PERFQUERY_DONOT_FLUSH_INTEL", }, { - 0x9115, - "GL_SYNC_FLAGS_APPLE", + 0x9115, "GL_SYNC_FLAGS_APPLE", }, { - 0x9286, - "GL_SRC_NV", + 0x9286, "GL_SRC_NV", }, { - 0x83F3, - "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE", + 0x83F3, "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE", }, { - 0x83F2, - "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE", + 0x83F2, "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE", }, { - 0x83F1, - "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", + 0x83F1, "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", }, { - 0x9114, - "GL_SYNC_STATUS_APPLE", + 0x9114, "GL_SYNC_STATUS_APPLE", }, { - 0x8C0A, - "GL_SGX_BINARY_IMG", + 0x8C0A, "GL_SGX_BINARY_IMG", }, { - 0x93BB, - "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", + 0x93BB, "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", }, { - 0x911C, - "GL_CONDITION_SATISFIED_APPLE", + 0x911C, "GL_CONDITION_SATISFIED_APPLE", }, { - 0x911B, - "GL_TIMEOUT_EXPIRED_APPLE", + 0x911B, "GL_TIMEOUT_EXPIRED_APPLE", }, { - 0x911A, - "GL_ALREADY_SIGNALED_APPLE", + 0x911A, "GL_ALREADY_SIGNALED_APPLE", }, { - 0x9284, - "GL_CONJOINT_NV", + 0x9284, "GL_CONJOINT_NV", }, { - 0x9124, - "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT", + 0x9124, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT", }, { - 0x911D, - "GL_WAIT_FAILED_APPLE", + 0x911D, "GL_WAIT_FAILED_APPLE", }, { - 0x929A, - "GL_COLORBURN_KHR", + 0x929A, "GL_COLORBURN_KHR", }, { - 0x929B, - "GL_HARDLIGHT_KHR", + 0x929B, "GL_HARDLIGHT_KHR", }, { - 0x929C, - "GL_SOFTLIGHT_KHR", + 0x929C, "GL_SOFTLIGHT_KHR", }, { - 0x846D, - "GL_ALIASED_POINT_SIZE_RANGE", + 0x846D, "GL_ALIASED_POINT_SIZE_RANGE", }, { - 0x929E, - "GL_DIFFERENCE_KHR", + 0x929E, "GL_DIFFERENCE_KHR", }, { - 0x929F, - "GL_MINUS_NV", + 0x929F, "GL_MINUS_NV", }, { - 0x9282, - "GL_UNCORRELATED_NV", + 0x9282, "GL_UNCORRELATED_NV", }, { - 0x9298, - "GL_LIGHTEN_KHR", + 0x9298, "GL_LIGHTEN_KHR", }, { - 0x9299, - "GL_COLORDODGE_KHR", + 0x9299, "GL_COLORDODGE_KHR", }, { - 0x9111, - "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE", + 0x9111, "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE", }, { - 0x93A6, - "GL_PROGRAM_BINARY_ANGLE", + 0x93A6, "GL_PROGRAM_BINARY_ANGLE", }, { - 0x9117, - "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE", + 0x9117, "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE", }, { - 0x93A0, - "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE", + 0x93A0, "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE", }, { - 0x93A3, - "GL_FRAMEBUFFER_ATTACHMENT_ANGLE", + 0x93A3, "GL_FRAMEBUFFER_ATTACHMENT_ANGLE", }, { - 0x93A2, - "GL_TEXTURE_USAGE_ANGLE", + 0x93A2, "GL_TEXTURE_USAGE_ANGLE", }, { - 0x8802, - "GL_STENCIL_BACK_PASS_DEPTH_FAIL", + 0x8802, "GL_STENCIL_BACK_PASS_DEPTH_FAIL", }, { - 0x9119, - "GL_SIGNALED_APPLE", + 0x9119, "GL_SIGNALED_APPLE", }, { - 0x9118, - "GL_UNSIGNALED_APPLE", + 0x9118, "GL_UNSIGNALED_APPLE", }, { - 0x9294, - "GL_MULTIPLY_KHR", + 0x9294, "GL_MULTIPLY_KHR", }, { - 0x9295, - "GL_SCREEN_KHR", + 0x9295, "GL_SCREEN_KHR", }, { - 0x9296, - "GL_OVERLAY_KHR", + 0x9296, "GL_OVERLAY_KHR", }, { - 0x9297, - "GL_DARKEN_KHR", + 0x9297, "GL_DARKEN_KHR", }, { - 0x0020, - "GL_MAP_UNSYNCHRONIZED_BIT_EXT", + 0x0020, "GL_MAP_UNSYNCHRONIZED_BIT_EXT", }, { - 0x8E78, - "GL_TESS_GEN_VERTEX_ORDER_EXT", + 0x8E78, "GL_TESS_GEN_VERTEX_ORDER_EXT", }, { - 0x8C01, - "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG", + 0x8C01, "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG", }, { - 0x8C00, - "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG", + 0x8C00, "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG", }, { - 0x8A52, - "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT", + 0x8A52, "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT", }, { - 0x8C02, - "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG", + 0x8C02, "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG", }, { - 0x84C9, - "GL_TEXTURE9", + 0x84C9, "GL_TEXTURE9", }, { - 0x84C8, - "GL_TEXTURE8", + 0x84C8, "GL_TEXTURE8", }, { - 0x8869, - "GL_MAX_VERTEX_ATTRIBS", + 0x8869, "GL_MAX_VERTEX_ATTRIBS", }, { - 0x84C3, - "GL_TEXTURE3", + 0x84C3, "GL_TEXTURE3", }, { - 0x84C2, - "GL_TEXTURE2", + 0x84C2, "GL_TEXTURE2", }, { - 0x84C1, - "GL_TEXTURE1", + 0x84C1, "GL_TEXTURE1", }, { - 0x84C0, - "GL_TEXTURE0", + 0x84C0, "GL_TEXTURE0", }, { - 0x84C7, - "GL_TEXTURE7", + 0x84C7, "GL_TEXTURE7", }, { - 0x84C6, - "GL_TEXTURE6", + 0x84C6, "GL_TEXTURE6", }, { - 0x84C5, - "GL_TEXTURE5", + 0x84C5, "GL_TEXTURE5", }, { - 0x8803, - "GL_STENCIL_BACK_PASS_DEPTH_PASS", + 0x8803, "GL_STENCIL_BACK_PASS_DEPTH_PASS", }, { - 0x928A, - "GL_SRC_IN_NV", + 0x928A, "GL_SRC_IN_NV", }, { - 0x8518, - "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y", + 0x8518, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y", }, { - 0x8519, - "GL_TEXTURE_CUBE_MAP_POSITIVE_Z", + 0x8519, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z", }, { - 0x8514, - "GL_TEXTURE_BINDING_CUBE_MAP", + 0x8514, "GL_TEXTURE_BINDING_CUBE_MAP", }, { - 0x8515, - "GL_TEXTURE_CUBE_MAP_POSITIVE_X", + 0x8515, "GL_TEXTURE_CUBE_MAP_POSITIVE_X", }, { - 0x8516, - "GL_TEXTURE_CUBE_MAP_NEGATIVE_X", + 0x8516, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X", }, { - 0x8517, - "GL_TEXTURE_CUBE_MAP_POSITIVE_Y", + 0x8517, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y", }, { - 0x8218, - "GL_FRAMEBUFFER_DEFAULT", + 0x8218, "GL_FRAMEBUFFER_DEFAULT", }, { - 0x8513, - "GL_TEXTURE_CUBE_MAP", + 0x8513, "GL_TEXTURE_CUBE_MAP", }, { - 0x8626, - "GL_CURRENT_VERTEX_ATTRIB", + 0x8626, "GL_CURRENT_VERTEX_ATTRIB", }, { - 0x92B1, - "GL_PLUS_CLAMPED_NV", + 0x92B1, "GL_PLUS_CLAMPED_NV", }, { - 0x92B0, - "GL_HSL_LUMINOSITY_KHR", + 0x92B0, "GL_HSL_LUMINOSITY_KHR", }, { - 0x92B3, - "GL_MINUS_CLAMPED_NV", + 0x92B3, "GL_MINUS_CLAMPED_NV", }, { - 0x92B2, - "GL_PLUS_CLAMPED_ALPHA_NV", + 0x92B2, "GL_PLUS_CLAMPED_ALPHA_NV", }, { - 0x8765, - "GL_BUFFER_USAGE", + 0x8765, "GL_BUFFER_USAGE", }, { - 0x8764, - "GL_BUFFER_SIZE", + 0x8764, "GL_BUFFER_SIZE", }, { - 0x8B99, - "GL_PALETTE8_RGB5_A1_OES", + 0x8B99, "GL_PALETTE8_RGB5_A1_OES", }, { - 0x0503, - "GL_STACK_OVERFLOW_KHR", + 0x0503, "GL_STACK_OVERFLOW_KHR", }, { - 0x0502, - "GL_INVALID_OPERATION", + 0x0502, "GL_INVALID_OPERATION", }, { - 0x0501, - "GL_INVALID_VALUE", + 0x0501, "GL_INVALID_VALUE", }, { - 0x0500, - "GL_INVALID_ENUM", + 0x0500, "GL_INVALID_ENUM", }, { - 0x0507, - "GL_CONTEXT_LOST_KHR", + 0x0507, "GL_CONTEXT_LOST_KHR", }, { - 0x0506, - "GL_INVALID_FRAMEBUFFER_OPERATION", + 0x0506, "GL_INVALID_FRAMEBUFFER_OPERATION", }, { - 0x0505, - "GL_OUT_OF_MEMORY", + 0x0505, "GL_OUT_OF_MEMORY", }, { - 0x0504, - "GL_STACK_UNDERFLOW_KHR", + 0x0504, "GL_STACK_UNDERFLOW_KHR", }, { - 0x0CF4, - "GL_UNPACK_SKIP_PIXELS_EXT", + 0x0CF4, "GL_UNPACK_SKIP_PIXELS_EXT", }, { - 0x0B44, - "GL_CULL_FACE", + 0x0B44, "GL_CULL_FACE", }, { - 0x8B5E, - "GL_SAMPLER_2D", + 0x8B5E, "GL_SAMPLER_2D", }, { - 0x0B46, - "GL_FRONT_FACE", + 0x0B46, "GL_FRONT_FACE", }, { - 0x8FB3, - "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM", + 0x8FB3, "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM", }, { - 0x824A, - "GL_DEBUG_SOURCE_APPLICATION_KHR", + 0x824A, "GL_DEBUG_SOURCE_APPLICATION_KHR", }, { - 0x824B, - "GL_DEBUG_SOURCE_OTHER_KHR", + 0x824B, "GL_DEBUG_SOURCE_OTHER_KHR", }, { - 0x824C, - "GL_DEBUG_TYPE_ERROR_KHR", + 0x824C, "GL_DEBUG_TYPE_ERROR_KHR", }, { - 0x824D, - "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR", + 0x824D, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR", }, { - 0x824E, - "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR", + 0x824E, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR", }, { - 0x824F, - "GL_DEBUG_TYPE_PORTABILITY_KHR", + 0x824F, "GL_DEBUG_TYPE_PORTABILITY_KHR", }, { - 0x8DD7, - "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY", + 0x8DD7, "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY", }, { - 0x8B31, - "GL_VERTEX_SHADER", + 0x8B31, "GL_VERTEX_SHADER", }, { - 0x8B30, - "GL_FRAGMENT_SHADER", + 0x8B30, "GL_FRAGMENT_SHADER", }, { - 0x8FB1, - "GL_CPU_OPTIMIZED_QCOM", + 0x8FB1, "GL_CPU_OPTIMIZED_QCOM", }, { - 0x93D2, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", + 0x93D2, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", }, { - 0x82FB, - "GL_CONTEXT_RELEASE_BEHAVIOR_KHR", + 0x82FB, "GL_CONTEXT_RELEASE_BEHAVIOR_KHR", }, { - 0x8B5A, - "GL_FLOAT_MAT2", + 0x8B5A, "GL_FLOAT_MAT2", }, { - 0x84D8, - "GL_TEXTURE24", + 0x84D8, "GL_TEXTURE24", }, { - 0x84D9, - "GL_TEXTURE25", + 0x84D9, "GL_TEXTURE25", }, { - 0x84D6, - "GL_TEXTURE22", + 0x84D6, "GL_TEXTURE22", }, { - 0x84D7, - "GL_TEXTURE23", + 0x84D7, "GL_TEXTURE23", }, { - 0x84D4, - "GL_TEXTURE20", + 0x84D4, "GL_TEXTURE20", }, { - 0x0D05, - "GL_PACK_ALIGNMENT", + 0x0D05, "GL_PACK_ALIGNMENT", }, { - 0x84D2, - "GL_TEXTURE18", + 0x84D2, "GL_TEXTURE18", }, { - 0x84D3, - "GL_TEXTURE19", + 0x84D3, "GL_TEXTURE19", }, { - 0x84D0, - "GL_TEXTURE16", + 0x84D0, "GL_TEXTURE16", }, { - 0x84D1, - "GL_TEXTURE17", + 0x84D1, "GL_TEXTURE17", }, { - 0x93D1, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", + 0x93D1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", }, { - 0x84DF, - "GL_TEXTURE31", + 0x84DF, "GL_TEXTURE31", }, { - 0x8B97, - "GL_PALETTE8_R5_G6_B5_OES", + 0x8B97, "GL_PALETTE8_R5_G6_B5_OES", }, { - 0x84DD, - "GL_TEXTURE29", + 0x84DD, "GL_TEXTURE29", }, { - 0x84DE, - "GL_TEXTURE30", + 0x84DE, "GL_TEXTURE30", }, { - 0x84DB, - "GL_TEXTURE27", + 0x84DB, "GL_TEXTURE27", }, { - 0x84DC, - "GL_TEXTURE28", + 0x84DC, "GL_TEXTURE28", }, { - 0x6002, - "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM", + 0x6002, "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM", }, { - 0x84DA, - "GL_TEXTURE26", + 0x84DA, "GL_TEXTURE26", }, { - 0x8242, - "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR", + 0x8242, "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR", }, { - 0x8243, - "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR", + 0x8243, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR", }, { - 0x8244, - "GL_DEBUG_CALLBACK_FUNCTION_KHR", + 0x8244, "GL_DEBUG_CALLBACK_FUNCTION_KHR", }, { - 0x8245, - "GL_DEBUG_CALLBACK_USER_PARAM_KHR", + 0x8245, "GL_DEBUG_CALLBACK_USER_PARAM_KHR", }, { - 0x8246, - "GL_DEBUG_SOURCE_API_KHR", + 0x8246, "GL_DEBUG_SOURCE_API_KHR", }, { - 0x8247, - "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR", + 0x8247, "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR", }, { - 0x8248, - "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR", + 0x8248, "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR", }, { - 0x8249, - "GL_DEBUG_SOURCE_THIRD_PARTY_KHR", + 0x8249, "GL_DEBUG_SOURCE_THIRD_PARTY_KHR", }, { - 0x88ED, - "GL_PIXEL_PACK_BUFFER_BINDING", + 0x88ED, "GL_PIXEL_PACK_BUFFER_BINDING", }, { - 0x8B94, - "GL_PALETTE4_RGB5_A1_OES", + 0x8B94, "GL_PALETTE4_RGB5_A1_OES", }, { - 0x94F4, - "GL_PERFQUERY_COUNTER_RAW_INTEL", + 0x94F4, "GL_PERFQUERY_COUNTER_RAW_INTEL", }, { - 0x823C, - "GL_RG32UI", + 0x823C, "GL_RG32UI", }, { - 0x8A29, - "GL_UNIFORM_BUFFER_START", + 0x8A29, "GL_UNIFORM_BUFFER_START", }, { - 0x8A28, - "GL_UNIFORM_BUFFER_BINDING", + 0x8A28, "GL_UNIFORM_BUFFER_BINDING", }, { - 0x92BE, - "GL_PRIMITIVE_BOUNDING_BOX_EXT", + 0x92BE, "GL_PRIMITIVE_BOUNDING_BOX_EXT", }, { - 0x8645, - "GL_VERTEX_ATTRIB_ARRAY_POINTER", + 0x8645, "GL_VERTEX_ATTRIB_ARRAY_POINTER", }, { - 0x8865, - "GL_CURRENT_QUERY_EXT", + 0x8865, "GL_CURRENT_QUERY_EXT", }, { - 0x8E5B, - "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES", + 0x8E5B, "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES", }, { - 0x8E5C, - "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES", + 0x8E5C, "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES", }, { - 0x8E5D, - "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES", + 0x8E5D, "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES", }, { - 0x906A, - "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT", + 0x906A, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT", }, { - 0x906F, - "GL_RGB10_A2UI", + 0x906F, "GL_RGB10_A2UI", }, { - 0x8E72, - "GL_PATCH_VERTICES_EXT", + 0x8E72, "GL_PATCH_VERTICES_EXT", }, { - 0x8BD3, - "GL_TEXTURE_HEIGHT_QCOM", + 0x8BD3, "GL_TEXTURE_HEIGHT_QCOM", }, { - 0x87FA, - "GL_3DC_XY_AMD", + 0x87FA, "GL_3DC_XY_AMD", }, { - 0x84C4, - "GL_TEXTURE4", + 0x84C4, "GL_TEXTURE4", }, { - 0x821C, - "GL_MINOR_VERSION", + 0x821C, "GL_MINOR_VERSION", }, { - 0x8E8A, - "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT", + 0x8E8A, "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT", }, { - 0x85B5, - "GL_VERTEX_ARRAY_BINDING_OES", + 0x85B5, "GL_VERTEX_ARRAY_BINDING_OES", }, { - 0x8253, - "GL_GUILTY_CONTEXT_RESET_KHR", + 0x8253, "GL_GUILTY_CONTEXT_RESET_KHR", }, { - 0x8D6B, - "GL_MAX_ELEMENT_INDEX", + 0x8D6B, "GL_MAX_ELEMENT_INDEX", }, { - 0x8D6C, - "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT", + 0x8D6C, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT", }, { - 0x92A1, - "GL_CONTRAST_NV", + 0x92A1, "GL_CONTRAST_NV", }, { - 0x8252, - "GL_LOSE_CONTEXT_ON_RESET_KHR", + 0x8252, "GL_LOSE_CONTEXT_ON_RESET_KHR", }, { - 0x8C4C, - "GL_COMPRESSED_SRGB_S3TC_DXT1_NV", + 0x8C4C, "GL_COMPRESSED_SRGB_S3TC_DXT1_NV", }, { - 0x8C4E, - "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV", + 0x8C4E, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV", }, { - 0x8251, - "GL_DEBUG_TYPE_OTHER_KHR", + 0x8251, "GL_DEBUG_TYPE_OTHER_KHR", }, { - 0x8C4F, - "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV", + 0x8C4F, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV", }, { - 0x9309, - "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT", + 0x9309, "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT", }, { - 0x93E9, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES", + 0x93E9, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES", }, { - 0x93E8, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES", + 0x93E8, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES", }, { - 0x8C43, - "GL_SRGB8_ALPHA8_EXT", + 0x8C43, "GL_SRGB8_ALPHA8_EXT", }, { - 0x8C42, - "GL_SRGB_ALPHA_EXT", + 0x8C42, "GL_SRGB_ALPHA_EXT", }, { - 0x8C45, - "GL_SLUMINANCE8_ALPHA8_NV", + 0x8C45, "GL_SLUMINANCE8_ALPHA8_NV", }, { - 0x8C44, - "GL_SLUMINANCE_ALPHA_NV", + 0x8C44, "GL_SLUMINANCE_ALPHA_NV", }, { - 0x8C47, - "GL_SLUMINANCE8_NV", + 0x8C47, "GL_SLUMINANCE8_NV", }, { - 0x8C46, - "GL_SLUMINANCE_NV", + 0x8C46, "GL_SLUMINANCE_NV", }, { - 0x93E1, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES", + 0x93E1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES", }, { - 0x93E0, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES", + 0x93E0, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES", }, { - 0x93E3, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES", + 0x93E3, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES", }, { - 0x93E2, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES", + 0x93E2, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES", }, { - 0x93E5, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES", + 0x93E5, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES", }, { - 0x93E4, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES", + 0x93E4, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES", }, { - 0x93E7, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES", + 0x93E7, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES", }, { - 0x93E6, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES", + 0x93E6, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES", }, { - 0x8D68, - "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES", + 0x8D68, "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES", }, { - 0x8E82, - "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT", + 0x8E82, "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT", }, { - 0x8E81, - "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT", + 0x8E81, "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT", }, { - 0x85BB, - "GL_UNSIGNED_SHORT_8_8_REV_APPLE", + 0x85BB, "GL_UNSIGNED_SHORT_8_8_REV_APPLE", }, { - 0x8E87, - "GL_TESS_EVALUATION_SHADER_EXT", + 0x8E87, "GL_TESS_EVALUATION_SHADER_EXT", }, { - 0x8E86, - "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT", + 0x8E86, "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT", }, { - 0x8E85, - "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT", + 0x8E85, "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT", }, { - 0x8E84, - "GL_MAX_TESS_PATCH_COMPONENTS_EXT", + 0x8E84, "GL_MAX_TESS_PATCH_COMPONENTS_EXT", }, { - 0x8D61, - "GL_HALF_FLOAT_OES", + 0x8D61, "GL_HALF_FLOAT_OES", }, { - 0x8D62, - "GL_RGB565", + 0x8D62, "GL_RGB565", }, { - 0x8E88, - "GL_TESS_CONTROL_SHADER_EXT", + 0x8E88, "GL_TESS_CONTROL_SHADER_EXT", }, { - 0x8D64, - "GL_ETC1_RGB8_OES", + 0x8D64, "GL_ETC1_RGB8_OES", }, { - 0x8D65, - "GL_TEXTURE_EXTERNAL_OES", + 0x8D65, "GL_TEXTURE_EXTERNAL_OES", }, { - 0x8D66, - "GL_SAMPLER_EXTERNAL_OES", + 0x8D66, "GL_SAMPLER_EXTERNAL_OES", }, { - 0x8D67, - "GL_TEXTURE_BINDING_EXTERNAL_OES", + 0x8D67, "GL_TEXTURE_BINDING_EXTERNAL_OES", }, { - 0x10000000, - "GL_MULTISAMPLE_BUFFER_BIT4_QCOM", + 0x10000000, "GL_MULTISAMPLE_BUFFER_BIT4_QCOM", }, { - 0x04000000, - "GL_MULTISAMPLE_BUFFER_BIT2_QCOM", + 0x04000000, "GL_MULTISAMPLE_BUFFER_BIT2_QCOM", }, { - 0x90D7, - "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT", + 0x90D7, "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT", }, { - 0x90D9, - "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT", + 0x90D9, "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT", }, { - 0x90D8, - "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT", + 0x90D8, "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT", }, { - 0x8CEE, - "GL_COLOR_ATTACHMENT14_EXT", + 0x8CEE, "GL_COLOR_ATTACHMENT14_EXT", }, { - 0x8DC7, - "GL_UNSIGNED_INT_VEC3", + 0x8DC7, "GL_UNSIGNED_INT_VEC3", }, { - 0x1701, - "GL_PATH_PROJECTION_CHROMIUM", + 0x1701, "GL_PATH_PROJECTION_CHROMIUM", }, { - 0x2800, - "GL_TEXTURE_MAG_FILTER", + 0x2800, "GL_TEXTURE_MAG_FILTER", }, { - 0x2801, - "GL_TEXTURE_MIN_FILTER", + 0x2801, "GL_TEXTURE_MIN_FILTER", }, { - 0x2802, - "GL_TEXTURE_WRAP_S", + 0x2802, "GL_TEXTURE_WRAP_S", }, { - 0x2803, - "GL_TEXTURE_WRAP_T", + 0x2803, "GL_TEXTURE_WRAP_T", }, { - 0x8DCB, - "GL_INT_SAMPLER_3D", + 0x8DCB, "GL_INT_SAMPLER_3D", }, { - 0x3007, - "GL_CLIP_DISTANCE7_APPLE", + 0x3007, "GL_CLIP_DISTANCE7_APPLE", }, { - 0x2703, - "GL_LINEAR_MIPMAP_LINEAR", + 0x2703, "GL_LINEAR_MIPMAP_LINEAR", }, { - 0x3005, - "GL_CLIP_DISTANCE5_APPLE", + 0x3005, "GL_CLIP_DISTANCE5_APPLE", }, { - 0x3004, - "GL_CLIP_DISTANCE4_APPLE", + 0x3004, "GL_CLIP_DISTANCE4_APPLE", }, { - 0x8B98, - "GL_PALETTE8_RGBA4_OES", + 0x8B98, "GL_PALETTE8_RGBA4_OES", }, { - 0x3002, - "GL_CLIP_DISTANCE2_APPLE", + 0x3002, "GL_CLIP_DISTANCE2_APPLE", }, { - 0x3001, - "GL_CLIP_DISTANCE1_APPLE", + 0x3001, "GL_CLIP_DISTANCE1_APPLE", }, { - 0x2702, - "GL_NEAREST_MIPMAP_LINEAR", + 0x2702, "GL_NEAREST_MIPMAP_LINEAR", }, { - 0x1F03, - "GL_EXTENSIONS", + 0x1F03, "GL_EXTENSIONS", }, { - 0x1F02, - "GL_VERSION", + 0x1F02, "GL_VERSION", }, { - 0x1F01, - "GL_RENDERER", + 0x1F01, "GL_RENDERER", }, { - 0x1F00, - "GL_VENDOR", + 0x1F00, "GL_VENDOR", }, { - 0x9247, - "GL_OVERLAY_TRANSFORM_FLIP_VERTICAL_CHROMIUM", + 0x9247, "GL_OVERLAY_TRANSFORM_FLIP_VERTICAL_CHROMIUM", }, { - 0x2701, - "GL_LINEAR_MIPMAP_NEAREST", + 0x2701, "GL_LINEAR_MIPMAP_NEAREST", }, { - 0x9245, - "GL_OVERLAY_TRANSFORM_NONE_CHROMIUM", + 0x9245, "GL_OVERLAY_TRANSFORM_NONE_CHROMIUM", }, { - 0x92B4, - "GL_INVERT_OVG_NV", + 0x92B4, "GL_INVERT_OVG_NV", }, { - 0x9249, - "GL_OVERLAY_TRANSFORM_ROTATE_180_CHROMIUM", + 0x9249, "GL_OVERLAY_TRANSFORM_ROTATE_180_CHROMIUM", }, { - 0x0B94, - "GL_STENCIL_FAIL", + 0x0B94, "GL_STENCIL_FAIL", }, { - 0x8B4A, - "GL_MAX_VERTEX_UNIFORM_COMPONENTS", + 0x8B4A, "GL_MAX_VERTEX_UNIFORM_COMPONENTS", }, { - 0x8B4B, - "GL_MAX_VARYING_COMPONENTS", + 0x8B4B, "GL_MAX_VARYING_COMPONENTS", }, { - 0x8B4C, - "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS", + 0x8B4C, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS", }, { - 0x8B4D, - "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS", + 0x8B4D, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS", }, { - 0x8B4F, - "GL_SHADER_TYPE", + 0x8B4F, "GL_SHADER_TYPE", }, { - 0x9122, - "GL_MAX_VERTEX_OUTPUT_COMPONENTS", + 0x9122, "GL_MAX_VERTEX_OUTPUT_COMPONENTS", }, { - 0x9123, - "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT", + 0x9123, "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT", }, { - 0x83FB, - "GL_PERFQUERY_WAIT_INTEL", + 0x83FB, "GL_PERFQUERY_WAIT_INTEL", }, { - 0x9121, - "GL_BUFFER_MAP_OFFSET", + 0x9121, "GL_BUFFER_MAP_OFFSET", }, { - 0x00004000, - "GL_COLOR_BUFFER_BIT", + 0x00004000, "GL_COLOR_BUFFER_BIT", }, { - 0x9125, - "GL_MAX_FRAGMENT_INPUT_COMPONENTS", + 0x9125, "GL_MAX_FRAGMENT_INPUT_COMPONENTS", }, { - 0x00000010, - "GL_TESS_EVALUATION_SHADER_BIT_EXT", + 0x00000010, "GL_TESS_EVALUATION_SHADER_BIT_EXT", }, { - 0x8834, - "GL_DRAW_BUFFER15_EXT", + 0x8834, "GL_DRAW_BUFFER15_EXT", }, { - 0x8833, - "GL_DRAW_BUFFER14_EXT", + 0x8833, "GL_DRAW_BUFFER14_EXT", }, { - 0x8832, - "GL_DRAW_BUFFER13_EXT", + 0x8832, "GL_DRAW_BUFFER13_EXT", }, { - 0x8831, - "GL_DRAW_BUFFER12_EXT", + 0x8831, "GL_DRAW_BUFFER12_EXT", }, { - 0x8830, - "GL_DRAW_BUFFER11_EXT", + 0x8830, "GL_DRAW_BUFFER11_EXT", }, { - 0x8DC5, - "GL_SAMPLER_CUBE_SHADOW_NV", + 0x8DC5, "GL_SAMPLER_CUBE_SHADOW_NV", }, { - 0x94FF, - "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL", + 0x94FF, "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL", }, { - 0x94FE, - "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL", + 0x94FE, "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL", }, { - 0x94FD, - "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL", + 0x94FD, "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL", }, { - 0x94FC, - "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL", + 0x94FC, "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL", }, { - 0x94FB, - "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL", + 0x94FB, "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL", }, { - 0x93B8, - "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", + 0x93B8, "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", }, { - 0x8B65, - "GL_FLOAT_MAT2x3_NV", + 0x8B65, "GL_FLOAT_MAT2x3_NV", }, { - 0x9241, - "GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM", + 0x9241, "GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM", }, { - 0x00010000, - "GL_STENCIL_BUFFER_BIT0_QCOM", + 0x00010000, "GL_STENCIL_BUFFER_BIT0_QCOM", }, { - 0x83FA, - "GL_PERFQUERY_FLUSH_INTEL", + 0x83FA, "GL_PERFQUERY_FLUSH_INTEL", }, { - 0x0D03, - "GL_PACK_SKIP_ROWS", + 0x0D03, "GL_PACK_SKIP_ROWS", }, { - 0x84F3, - "GL_FENCE_STATUS_NV", + 0x84F3, "GL_FENCE_STATUS_NV", }, { - 0x88E6, - "GL_STATIC_COPY", + 0x88E6, "GL_STATIC_COPY", }, { - 0x0B93, - "GL_STENCIL_VALUE_MASK", + 0x0B93, "GL_STENCIL_VALUE_MASK", }, { - 0x0B92, - "GL_STENCIL_FUNC", + 0x0B92, "GL_STENCIL_FUNC", }, { - 0x0B91, - "GL_STENCIL_CLEAR_VALUE", + 0x0B91, "GL_STENCIL_CLEAR_VALUE", }, { - 0x883D, - "GL_BLEND_EQUATION_ALPHA", + 0x883D, "GL_BLEND_EQUATION_ALPHA", }, { - 0x0B97, - "GL_STENCIL_REF", + 0x0B97, "GL_STENCIL_REF", }, { - 0x0B96, - "GL_STENCIL_PASS_DEPTH_PASS", + 0x0B96, "GL_STENCIL_PASS_DEPTH_PASS", }, { - 0x0B95, - "GL_STENCIL_PASS_DEPTH_FAIL", + 0x0B95, "GL_STENCIL_PASS_DEPTH_FAIL", }, { - 0x2700, - "GL_NEAREST_MIPMAP_NEAREST", + 0x2700, "GL_NEAREST_MIPMAP_NEAREST", }, { - 0x94F5, - "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL", + 0x94F5, "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL", }, { - 0x0B98, - "GL_STENCIL_WRITEMASK", + 0x0B98, "GL_STENCIL_WRITEMASK", }, { - 0x94F3, - "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL", + 0x94F3, "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL", }, { - 0x94F2, - "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL", + 0x94F2, "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL", }, { - 0x94F1, - "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL", + 0x94F1, "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL", }, { - 0x94F0, - "GL_PERFQUERY_COUNTER_EVENT_INTEL", + 0x94F0, "GL_PERFQUERY_COUNTER_EVENT_INTEL", }, { - 0x8B40, - "GL_PROGRAM_OBJECT_EXT", + 0x8B40, "GL_PROGRAM_OBJECT_EXT", }, { - 0x1004, - "GL_TEXTURE_BORDER_COLOR_EXT", + 0x1004, "GL_TEXTURE_BORDER_COLOR_EXT", }, { - 0x8A2D, - "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", + 0x8A2D, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", }, { - 0x8B48, - "GL_SHADER_OBJECT_EXT", + 0x8B48, "GL_SHADER_OBJECT_EXT", }, { - 0x8B49, - "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS", + 0x8B49, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS", }, { - 0x813A, - "GL_TEXTURE_MIN_LOD", + 0x813A, "GL_TEXTURE_MIN_LOD", }, { - 0x8DE1, - "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT", + 0x8DE1, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT", }, { - 0x8DE0, - "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT", + 0x8DE0, "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT", }, { - 0x924C, - "GL_MOUSE_POSITION_CHROMIUM", + 0x924C, "GL_MOUSE_POSITION_CHROMIUM", }, { - 0x924B, - "GL_SUBSCRIBED_VALUES_BUFFER_CHROMIUM", + 0x924B, "GL_SUBSCRIBED_VALUES_BUFFER_CHROMIUM", }, { - 0x924A, - "GL_OVERLAY_TRANSFORM_ROTATE_270_CHROMIUM", + 0x924A, "GL_OVERLAY_TRANSFORM_ROTATE_270_CHROMIUM", }, { - 0x8A2F, - "GL_MAX_UNIFORM_BUFFER_BINDINGS", + 0x8A2F, "GL_MAX_UNIFORM_BUFFER_BINDINGS", }, { - 0x20000000, - "GL_MULTISAMPLE_BUFFER_BIT5_QCOM", + 0x20000000, "GL_MULTISAMPLE_BUFFER_BIT5_QCOM", }, { - 64, - "GL_MAILBOX_SIZE_CHROMIUM", + 64, "GL_MAILBOX_SIZE_CHROMIUM", }, { - 0x0DE1, - "GL_TEXTURE_2D", + 0x0DE1, "GL_TEXTURE_2D", }, { - 0x8A2C, - "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT", + 0x8A2C, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT", }, { - 0x80C9, - "GL_BLEND_SRC_RGB", + 0x80C9, "GL_BLEND_SRC_RGB", }, { - 0x80C8, - "GL_BLEND_DST_RGB", + 0x80C8, "GL_BLEND_DST_RGB", }, { - 0x912F, - "GL_TEXTURE_IMMUTABLE_FORMAT_EXT", + 0x912F, "GL_TEXTURE_IMMUTABLE_FORMAT_EXT", }, { - 0x8A2B, - "GL_MAX_VERTEX_UNIFORM_BLOCKS", + 0x8A2B, "GL_MAX_VERTEX_UNIFORM_BLOCKS", }, { - 0x88EC, - "GL_PIXEL_UNPACK_BUFFER", + 0x88EC, "GL_PIXEL_UNPACK_BUFFER", }, { - 0x8D8F, - "GL_RGB8I", + 0x8D8F, "GL_RGB8I", }, { - 0x8059, - "GL_RGB10_A2_EXT", + 0x8059, "GL_RGB10_A2_EXT", }, { - 0x8058, - "GL_RGBA8_OES", + 0x8058, "GL_RGBA8_OES", }, { - 0x8B93, - "GL_PALETTE4_RGBA4_OES", + 0x8B93, "GL_PALETTE4_RGBA4_OES", }, { - 0x88EB, - "GL_PIXEL_PACK_BUFFER", + 0x88EB, "GL_PIXEL_PACK_BUFFER", }, { - 0x8E83, - "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT", + 0x8E83, "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT", }, { - 0x8051, - "GL_RGB8_OES", + 0x8051, "GL_RGB8_OES", }, { - 0x8CAD, - "GL_DEPTH32F_STENCIL8", + 0x8CAD, "GL_DEPTH32F_STENCIL8", }, { - 0x8052, - "GL_RGB10_EXT", + 0x8052, "GL_RGB10_EXT", }, { - 0x8CAB, - "GL_RENDERBUFFER_SAMPLES_ANGLE", + 0x8CAB, "GL_RENDERBUFFER_SAMPLES_ANGLE", }, { - 0x8CAC, - "GL_DEPTH_COMPONENT32F", + 0x8CAC, "GL_DEPTH_COMPONENT32F", }, { - 0x8057, - "GL_RGB5_A1", + 0x8057, "GL_RGB5_A1", }, { - 0x8056, - "GL_RGBA4", + 0x8056, "GL_RGBA4", }, { - 0x8232, - "GL_R8UI", + 0x8232, "GL_R8UI", }, { - 0x150A, - "GL_INVERT", + 0x150A, "GL_INVERT", }, { - 0x01000000, - "GL_MULTISAMPLE_BUFFER_BIT0_QCOM", + 0x01000000, "GL_MULTISAMPLE_BUFFER_BIT0_QCOM", }, { - 0x78ED, - "GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM", + 0x78ED, "GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM", }, { - 0x78EE, - "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM", + 0x78EE, "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM", }, { - 0x6001, - "GL_TEXTURE_POOL_MANAGED_CHROMIUM", + 0x6001, "GL_TEXTURE_POOL_MANAGED_CHROMIUM", }, { - 0x0B45, - "GL_CULL_FACE_MODE", + 0x0B45, "GL_CULL_FACE_MODE", }, { - 0x8B92, - "GL_PALETTE4_R5_G6_B5_OES", + 0x8B92, "GL_PALETTE4_R5_G6_B5_OES", }, { - 0x00100000, - "GL_STENCIL_BUFFER_BIT4_QCOM", + 0x00100000, "GL_STENCIL_BUFFER_BIT4_QCOM", }, { - 0x8E4E, - "GL_LAST_VERTEX_CONVENTION_EXT", + 0x8E4E, "GL_LAST_VERTEX_CONVENTION_EXT", }, { - 0x8E4D, - "GL_FIRST_VERTEX_CONVENTION_EXT", + 0x8E4D, "GL_FIRST_VERTEX_CONVENTION_EXT", }, { - 0x8E24, - "GL_TRANSFORM_FEEDBACK_ACTIVE", + 0x8E24, "GL_TRANSFORM_FEEDBACK_ACTIVE", }, { - 0x8E45, - "GL_TEXTURE_SWIZZLE_A", + 0x8E45, "GL_TEXTURE_SWIZZLE_A", }, { - 0x8E44, - "GL_TEXTURE_SWIZZLE_B", + 0x8E44, "GL_TEXTURE_SWIZZLE_B", }, { - 0x8E43, - "GL_TEXTURE_SWIZZLE_G", + 0x8E43, "GL_TEXTURE_SWIZZLE_G", }, { - 0x8E42, - "GL_TEXTURE_SWIZZLE_R", + 0x8E42, "GL_TEXTURE_SWIZZLE_R", }, { - 0x8D20, - "GL_STENCIL_ATTACHMENT", + 0x8D20, "GL_STENCIL_ATTACHMENT", }, { - 0x8B91, - "GL_PALETTE4_RGBA8_OES", + 0x8B91, "GL_PALETTE4_RGBA8_OES", }, { - 0x00000200, - "GL_DEPTH_BUFFER_BIT1_QCOM", + 0x00000200, "GL_DEPTH_BUFFER_BIT1_QCOM", }, { - 0x00008000, - "GL_COVERAGE_BUFFER_BIT_NV", + 0x00008000, "GL_COVERAGE_BUFFER_BIT_NV", }, { - 0x1506, - "GL_XOR_NV", + 0x1506, "GL_XOR_NV", }, { - 0x8CA8, - "GL_READ_FRAMEBUFFER_ANGLE", + 0x8CA8, "GL_READ_FRAMEBUFFER_ANGLE", }, { - 0x8CA9, - "GL_DRAW_FRAMEBUFFER_ANGLE", + 0x8CA9, "GL_DRAW_FRAMEBUFFER_ANGLE", }, { - 0x8CA6, - "GL_FRAMEBUFFER_BINDING", + 0x8CA6, "GL_FRAMEBUFFER_BINDING", }, { - 0x8CA7, - "GL_RENDERBUFFER_BINDING", + 0x8CA7, "GL_RENDERBUFFER_BINDING", }, { - 0x8CA4, - "GL_STENCIL_BACK_VALUE_MASK", + 0x8CA4, "GL_STENCIL_BACK_VALUE_MASK", }, { - 0x8CA5, - "GL_STENCIL_BACK_WRITEMASK", + 0x8CA5, "GL_STENCIL_BACK_WRITEMASK", }, { - 0x8B90, - "GL_PALETTE4_RGB8_OES", + 0x8B90, "GL_PALETTE4_RGB8_OES", }, { - 0x8CA3, - "GL_STENCIL_BACK_REF", + 0x8CA3, "GL_STENCIL_BACK_REF", }, { - 0x80E8, - "GL_MAX_ELEMENTS_VERTICES", + 0x80E8, "GL_MAX_ELEMENTS_VERTICES", }, { - 0x80CB, - "GL_BLEND_SRC_ALPHA", + 0x80CB, "GL_BLEND_SRC_ALPHA", }, { - 0x80CA, - "GL_BLEND_DST_ALPHA", + 0x80CA, "GL_BLEND_DST_ALPHA", }, { - 0x8CE7, - "GL_COLOR_ATTACHMENT7_EXT", + 0x8CE7, "GL_COLOR_ATTACHMENT7_EXT", }, { - 0x93B0, - "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", + 0x93B0, "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", }, { - 0x93B1, - "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", + 0x93B1, "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", }, { - 0x93B2, - "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", + 0x93B2, "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", }, { - 0x93B3, - "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", + 0x93B3, "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", }, { - 0x93B4, - "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", + 0x93B4, "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", }, { - 0x93B5, - "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", + 0x93B5, "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", }, { - 0x93B6, - "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", + 0x93B6, "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", }, { - 0x93B7, - "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", + 0x93B7, "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", }, { - 0x8CD6, - "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT", + 0x8CD6, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT", }, { - 0x93B9, - "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", + 0x93B9, "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", }, { - 0x80E9, - "GL_MAX_ELEMENTS_INDICES", + 0x80E9, "GL_MAX_ELEMENTS_INDICES", }, { - 0x8CE5, - "GL_COLOR_ATTACHMENT5_EXT", + 0x8CE5, "GL_COLOR_ATTACHMENT5_EXT", }, { - 0x8C84, - "GL_TRANSFORM_FEEDBACK_BUFFER_START", + 0x8C84, "GL_TRANSFORM_FEEDBACK_BUFFER_START", }, { - 0x8DC2, - "GL_SAMPLER_BUFFER_EXT", + 0x8DC2, "GL_SAMPLER_BUFFER_EXT", }, { - 0x8C36, - "GL_SAMPLE_SHADING_OES", + 0x8C36, "GL_SAMPLE_SHADING_OES", }, { - 0x8C37, - "GL_MIN_SAMPLE_SHADING_VALUE_OES", + 0x8C37, "GL_MIN_SAMPLE_SHADING_VALUE_OES", }, { - 0x8F97, - "GL_RGBA8_SNORM", + 0x8F97, "GL_RGBA8_SNORM", }, { - 0x8CE9, - "GL_COLOR_ATTACHMENT9_EXT", + 0x8CE9, "GL_COLOR_ATTACHMENT9_EXT", }, { - 0x8DAD, - "GL_FLOAT_32_UNSIGNED_INT_24_8_REV", + 0x8DAD, "GL_FLOAT_32_UNSIGNED_INT_24_8_REV", }, { - 0x8B96, - "GL_PALETTE8_RGBA8_OES", + 0x8B96, "GL_PALETTE8_RGBA8_OES", }, { - 0x8872, - "GL_MAX_TEXTURE_IMAGE_UNITS", + 0x8872, "GL_MAX_TEXTURE_IMAGE_UNITS", }, { - 0x8DC6, - "GL_UNSIGNED_INT_VEC2", + 0x8DC6, "GL_UNSIGNED_INT_VEC2", }, { - 0x8905, - "GL_MAX_PROGRAM_TEXEL_OFFSET", + 0x8905, "GL_MAX_PROGRAM_TEXEL_OFFSET", }, { - 0x8508, - "GL_DECR_WRAP", + 0x8508, "GL_DECR_WRAP", }, { - 0x92AD, - "GL_HSL_HUE_KHR", + 0x92AD, "GL_HSL_HUE_KHR", }, { - 0x92AE, - "GL_HSL_SATURATION_KHR", + 0x92AE, "GL_HSL_SATURATION_KHR", }, { - 0x92AF, - "GL_HSL_COLOR_KHR", + 0x92AF, "GL_HSL_COLOR_KHR", }, { - 0x8BD4, - "GL_TEXTURE_DEPTH_QCOM", + 0x8BD4, "GL_TEXTURE_DEPTH_QCOM", }, { - 0x8DC4, - "GL_SAMPLER_2D_ARRAY_SHADOW_NV", + 0x8DC4, "GL_SAMPLER_2D_ARRAY_SHADOW_NV", }, { - 0x8507, - "GL_INCR_WRAP", + 0x8507, "GL_INCR_WRAP", }, { - 0x82FC, - "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR", + 0x82FC, "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR", }, { - 0x8895, - "GL_ELEMENT_ARRAY_BUFFER_BINDING", + 0x8895, "GL_ELEMENT_ARRAY_BUFFER_BINDING", }, { - 0x8894, - "GL_ARRAY_BUFFER_BINDING", + 0x8894, "GL_ARRAY_BUFFER_BINDING", }, { - 0x92A3, - "GL_INVERT_RGB_NV", + 0x92A3, "GL_INVERT_RGB_NV", }, { - 0x905F, - "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT", + 0x905F, "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT", }, { - 0x92A5, - "GL_LINEARBURN_NV", + 0x92A5, "GL_LINEARBURN_NV", }, { - 0x8893, - "GL_ELEMENT_ARRAY_BUFFER", + 0x8893, "GL_ELEMENT_ARRAY_BUFFER", }, { - 0x8892, - "GL_ARRAY_BUFFER", + 0x8892, "GL_ARRAY_BUFFER", }, { - 0x92A8, - "GL_PINLIGHT_NV", + 0x92A8, "GL_PINLIGHT_NV", }, { - 0x92A9, - "GL_HARDMIX_NV", + 0x92A9, "GL_HARDMIX_NV", }, { - 0x9112, - "GL_OBJECT_TYPE_APPLE", + 0x9112, "GL_OBJECT_TYPE_APPLE", }, { - 0x90CC, - "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT", + 0x90CC, "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT", }, { - 0x90CD, - "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT", + 0x90CD, "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT", }, { - 0x919F, - "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT", + 0x919F, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT", }, { - 0x919E, - "GL_TEXTURE_BUFFER_SIZE_EXT", + 0x919E, "GL_TEXTURE_BUFFER_SIZE_EXT", }, { - 0x919D, - "GL_TEXTURE_BUFFER_OFFSET_EXT", + 0x919D, "GL_TEXTURE_BUFFER_OFFSET_EXT", }, { - 0x8BD8, - "GL_TEXTURE_IMAGE_VALID_QCOM", + 0x8BD8, "GL_TEXTURE_IMAGE_VALID_QCOM", }, { - 0x9278, - "GL_COMPRESSED_RGBA8_ETC2_EAC", + 0x9278, "GL_COMPRESSED_RGBA8_ETC2_EAC", }, { - 0x9279, - "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", + 0x9279, "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", }, { - 0x8DA7, - "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT", + 0x8DA7, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT", }, { - 0x9272, - "GL_COMPRESSED_RG11_EAC", + 0x9272, "GL_COMPRESSED_RG11_EAC", }, { - 0x8DA8, - "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT", + 0x8DA8, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT", }, { - 0x9270, - "GL_COMPRESSED_R11_EAC", + 0x9270, "GL_COMPRESSED_R11_EAC", }, { - 0x9271, - "GL_COMPRESSED_SIGNED_R11_EAC", + 0x9271, "GL_COMPRESSED_SIGNED_R11_EAC", }, { - 0x9276, - "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", + 0x9276, "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", }, { - 0x887F, - "GL_GEOMETRY_SHADER_INVOCATIONS_EXT", + 0x887F, "GL_GEOMETRY_SHADER_INVOCATIONS_EXT", }, { - 0x8A3B, - "GL_UNIFORM_OFFSET", + 0x8A3B, "GL_UNIFORM_OFFSET", }, { - 0x9275, - "GL_COMPRESSED_SRGB8_ETC2", + 0x9275, "GL_COMPRESSED_SRGB8_ETC2", }, { - 0x84D5, - "GL_TEXTURE21", + 0x84D5, "GL_TEXTURE21", }, { - 0x8C3A, - "GL_R11F_G11F_B10F_APPLE", + 0x8C3A, "GL_R11F_G11F_B10F_APPLE", }, { - 0x8C3B, - "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE", + 0x8C3B, "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE", }, { - 0x8C3D, - "GL_RGB9_E5_APPLE", + 0x8C3D, "GL_RGB9_E5_APPLE", }, { - 0x8C3E, - "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE", + 0x8C3E, "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE", }, { - 0x9287, - "GL_DST_NV", + 0x9287, "GL_DST_NV", }, { - 0x93BA, - "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", + 0x93BA, "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", }, { - 0x9285, - "GL_BLEND_ADVANCED_COHERENT_KHR", + 0x9285, "GL_BLEND_ADVANCED_COHERENT_KHR", }, { - 0x93BC, - "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", + 0x93BC, "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", }, { - 0x93BD, - "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", + 0x93BD, "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", }, { - 0x84E8, - "GL_MAX_RENDERBUFFER_SIZE", + 0x84E8, "GL_MAX_RENDERBUFFER_SIZE", }, { - 0x9281, - "GL_BLEND_OVERLAP_NV", + 0x9281, "GL_BLEND_OVERLAP_NV", }, { - 0x9280, - "GL_BLEND_PREMULTIPLIED_SRC_NV", + 0x9280, "GL_BLEND_PREMULTIPLIED_SRC_NV", }, { - 0x00002000, - "GL_DEPTH_BUFFER_BIT5_QCOM", + 0x00002000, "GL_DEPTH_BUFFER_BIT5_QCOM", }, { - 0x8370, - "GL_MIRRORED_REPEAT", + 0x8370, "GL_MIRRORED_REPEAT", }, { - 0x84E0, - "GL_ACTIVE_TEXTURE", + 0x84E0, "GL_ACTIVE_TEXTURE", }, { - 0x8800, - "GL_STENCIL_BACK_FUNC", + 0x8800, "GL_STENCIL_BACK_FUNC", }, { - 0x8801, - "GL_STENCIL_BACK_FAIL", + 0x8801, "GL_STENCIL_BACK_FAIL", }, { - 0x0D33, - "GL_MAX_TEXTURE_SIZE", + 0x0D33, "GL_MAX_TEXTURE_SIZE", }, { - 0x0D32, - "GL_MAX_CLIP_DISTANCES_APPLE", + 0x0D32, "GL_MAX_CLIP_DISTANCES_APPLE", }, { - 0x8624, - "GL_VERTEX_ATTRIB_ARRAY_STRIDE", + 0x8624, "GL_VERTEX_ATTRIB_ARRAY_STRIDE", }, { - 0x8625, - "GL_VERTEX_ATTRIB_ARRAY_TYPE", + 0x8625, "GL_VERTEX_ATTRIB_ARRAY_TYPE", }, { - 0x8622, - "GL_VERTEX_ATTRIB_ARRAY_ENABLED", + 0x8622, "GL_VERTEX_ATTRIB_ARRAY_ENABLED", }, { - 0x8623, - "GL_VERTEX_ATTRIB_ARRAY_SIZE", + 0x8623, "GL_VERTEX_ATTRIB_ARRAY_SIZE", }, { - 0x8DB9, - "GL_FRAMEBUFFER_SRGB_EXT", + 0x8DB9, "GL_FRAMEBUFFER_SRGB_EXT", }, { - 0x9307, - "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT", + 0x9307, "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT", }, { - 0x8259, - "GL_ACTIVE_PROGRAM_EXT", + 0x8259, "GL_ACTIVE_PROGRAM_EXT", }, { - 0x8258, - "GL_PROGRAM_SEPARABLE_EXT", + 0x8258, "GL_PROGRAM_SEPARABLE_EXT", }, { - 0x8257, - "GL_PROGRAM_BINARY_RETRIEVABLE_HINT", + 0x8257, "GL_PROGRAM_BINARY_RETRIEVABLE_HINT", }, { - 0x8256, - "GL_RESET_NOTIFICATION_STRATEGY_KHR", + 0x8256, "GL_RESET_NOTIFICATION_STRATEGY_KHR", }, { - 0x8255, - "GL_UNKNOWN_CONTEXT_RESET_KHR", + 0x8255, "GL_UNKNOWN_CONTEXT_RESET_KHR", }, { - 0x8254, - "GL_INNOCENT_CONTEXT_RESET_KHR", + 0x8254, "GL_INNOCENT_CONTEXT_RESET_KHR", }, { - 0x1100, - "GL_DONT_CARE", + 0x1100, "GL_DONT_CARE", }, { - 0x1101, - "GL_FASTEST", + 0x1101, "GL_FASTEST", }, { - 0x1102, - "GL_NICEST", + 0x1102, "GL_NICEST", }, { - 0x8250, - "GL_DEBUG_TYPE_PERFORMANCE_KHR", + 0x8250, "GL_DEBUG_TYPE_PERFORMANCE_KHR", }, { - 0x8CEB, - "GL_COLOR_ATTACHMENT11_EXT", + 0x8CEB, "GL_COLOR_ATTACHMENT11_EXT", }, { - 0x8CEC, - "GL_COLOR_ATTACHMENT12_EXT", + 0x8CEC, "GL_COLOR_ATTACHMENT12_EXT", }, { - 0x0408, - "GL_FRONT_AND_BACK", + 0x0408, "GL_FRONT_AND_BACK", }, { - 0x8CEA, - "GL_COLOR_ATTACHMENT10_EXT", + 0x8CEA, "GL_COLOR_ATTACHMENT10_EXT", }, { - 0x8CEF, - "GL_COLOR_ATTACHMENT15_EXT", + 0x8CEF, "GL_COLOR_ATTACHMENT15_EXT", }, { - 0x8CED, - "GL_COLOR_ATTACHMENT13_EXT", + 0x8CED, "GL_COLOR_ATTACHMENT13_EXT", }, { - 0x8829, - "GL_DRAW_BUFFER4_EXT", + 0x8829, "GL_DRAW_BUFFER4_EXT", }, { - 0x0404, - "GL_FRONT", + 0x0404, "GL_FRONT", }, { - 0x0405, - "GL_BACK", + 0x0405, "GL_BACK", }, { - 0x88E1, - "GL_STREAM_READ", + 0x88E1, "GL_STREAM_READ", }, { - 0x88E0, - "GL_STREAM_DRAW", + 0x88E0, "GL_STREAM_DRAW", }, { - 0x88E2, - "GL_STREAM_COPY", + 0x88E2, "GL_STREAM_COPY", }, { - 0x88E5, - "GL_STATIC_READ", + 0x88E5, "GL_STATIC_READ", }, { - 0x88E4, - "GL_STATIC_DRAW", + 0x88E4, "GL_STATIC_DRAW", }, { - 0x93C6, - "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES", + 0x93C6, "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES", }, { - 0x88E9, - "GL_DYNAMIC_READ", + 0x88E9, "GL_DYNAMIC_READ", }, { - 0x88E8, - "GL_DYNAMIC_DRAW", + 0x88E8, "GL_DYNAMIC_DRAW", }, { - 0x9291, - "GL_PLUS_NV", + 0x9291, "GL_PLUS_NV", }, { - 0x8CAA, - "GL_READ_FRAMEBUFFER_BINDING_ANGLE", + 0x8CAA, "GL_READ_FRAMEBUFFER_BINDING_ANGLE", }, { - 0x93C5, - "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES", + 0x93C5, "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES", }, { - 0x40000000, - "GL_MULTISAMPLE_BUFFER_BIT6_QCOM", + 0x40000000, "GL_MULTISAMPLE_BUFFER_BIT6_QCOM", }, { - 0x88EA, - "GL_DYNAMIC_COPY", + 0x88EA, "GL_DYNAMIC_COPY", }, { - 0x9116, - "GL_SYNC_FENCE_APPLE", + 0x9116, "GL_SYNC_FENCE_APPLE", }, { - 0x93C4, - "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES", + 0x93C4, "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES", }, { - 0x88EE, - "GL_ETC1_SRGB8_NV", + 0x88EE, "GL_ETC1_SRGB8_NV", }, { - 0x78EC, - "GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM", + 0x78EC, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM", }, { - 0x88EF, - "GL_PIXEL_UNPACK_BUFFER_BINDING", + 0x88EF, "GL_PIXEL_UNPACK_BUFFER_BINDING", }, { - 0x93C3, - "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES", + 0x93C3, "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES", }, { - 0x00000800, - "GL_DEPTH_BUFFER_BIT3_QCOM", + 0x00000800, "GL_DEPTH_BUFFER_BIT3_QCOM", }, { - 0x1903, - "GL_RED_EXT", + 0x1903, "GL_RED_EXT", }, { - 0x93C2, - "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES", + 0x93C2, "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES", }, { - 0x8CE2, - "GL_COLOR_ATTACHMENT2_EXT", + 0x8CE2, "GL_COLOR_ATTACHMENT2_EXT", }, { - 0x8BC1, - "GL_COUNTER_RANGE_AMD", + 0x8BC1, "GL_COUNTER_RANGE_AMD", }, { - 0x8CE0, - "GL_COLOR_ATTACHMENT0", + 0x8CE0, "GL_COLOR_ATTACHMENT0", }, { - 0x8CE1, - "GL_COLOR_ATTACHMENT1_EXT", + 0x8CE1, "GL_COLOR_ATTACHMENT1_EXT", }, { - 0x8CE6, - "GL_COLOR_ATTACHMENT6_EXT", + 0x8CE6, "GL_COLOR_ATTACHMENT6_EXT", }, { - 0x93C1, - "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES", + 0x93C1, "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES", }, { - 0x8A1F, - "GL_RGB_422_APPLE", + 0x8A1F, "GL_RGB_422_APPLE", }, { - 0x93DC, - "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", + 0x93DC, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", }, { - 0x9292, - "GL_PLUS_DARKER_NV", + 0x9292, "GL_PLUS_DARKER_NV", }, { - 0x8CE8, - "GL_COLOR_ATTACHMENT8_EXT", + 0x8CE8, "GL_COLOR_ATTACHMENT8_EXT", }, { - 0x93C0, - "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES", + 0x93C0, "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES", }, { - 0x0C23, - "GL_COLOR_WRITEMASK", + 0x0C23, "GL_COLOR_WRITEMASK", }, { - 0x0C22, - "GL_COLOR_CLEAR_VALUE", + 0x0C22, "GL_COLOR_CLEAR_VALUE", }, { - 0x8A11, - "GL_UNIFORM_BUFFER", + 0x8A11, "GL_UNIFORM_BUFFER", }, { - 0x8823, - "GL_WRITEONLY_RENDERING_QCOM", + 0x8823, "GL_WRITEONLY_RENDERING_QCOM", }, { - 0x8824, - "GL_MAX_DRAW_BUFFERS_EXT", + 0x8824, "GL_MAX_DRAW_BUFFERS_EXT", }, { - 0x825E, - "GL_LAYER_PROVOKING_VERTEX_EXT", + 0x825E, "GL_LAYER_PROVOKING_VERTEX_EXT", }, { - 0x825A, - "GL_PROGRAM_PIPELINE_BINDING_EXT", + 0x825A, "GL_PROGRAM_PIPELINE_BINDING_EXT", }, { - 0x1909, - "GL_LUMINANCE", + 0x1909, "GL_LUMINANCE", }, { - 0x0D3A, - "GL_MAX_VIEWPORT_DIMS", + 0x0D3A, "GL_MAX_VIEWPORT_DIMS", }, { - 0x8B53, - "GL_INT_VEC2", + 0x8B53, "GL_INT_VEC2", }, { - 0x8826, - "GL_DRAW_BUFFER1_EXT", + 0x8826, "GL_DRAW_BUFFER1_EXT", }, { - 0x809E, - "GL_SAMPLE_ALPHA_TO_COVERAGE", + 0x809E, "GL_SAMPLE_ALPHA_TO_COVERAGE", }, { - 0x8BC0, - "GL_COUNTER_TYPE_AMD", + 0x8BC0, "GL_COUNTER_TYPE_AMD", }, { - 0x8BC3, - "GL_PERCENTAGE_AMD", + 0x8BC3, "GL_PERCENTAGE_AMD", }, { - 0x8BC2, - "GL_UNSIGNED_INT64_AMD", + 0x8BC2, "GL_UNSIGNED_INT64_AMD", }, { - 0x8BC5, - "GL_PERFMON_RESULT_SIZE_AMD", + 0x8BC5, "GL_PERFMON_RESULT_SIZE_AMD", }, { - 0x8BC4, - "GL_PERFMON_RESULT_AVAILABLE_AMD", + 0x8BC4, "GL_PERFMON_RESULT_AVAILABLE_AMD", }, { - 0x8BC6, - "GL_PERFMON_RESULT_AMD", + 0x8BC6, "GL_PERFMON_RESULT_AMD", }, }; diff --git a/ui/gl/gl_mock_autogen_gl.h b/ui/gl/gl_mock_autogen_gl.h index 77c69d08f85..832c85f5e06 100644 --- a/ui/gl/gl_mock_autogen_gl.h +++ b/ui/gl/gl_mock_autogen_gl.h @@ -169,6 +169,22 @@ MOCK_METHOD9(CopyTexSubImage3D, MOCK_METHOD0(CreateProgram, GLuint()); MOCK_METHOD1(CreateShader, GLuint(GLenum type)); MOCK_METHOD1(CullFace, void(GLenum mode)); +MOCK_METHOD2(DebugMessageCallbackKHR, + void(GLDEBUGPROCKHR callback, const void* userparam)); +MOCK_METHOD6(DebugMessageControlKHR, + void(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint* ids, + GLboolean enabled)); +MOCK_METHOD6(DebugMessageInsertKHR, + void(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* buf)); MOCK_METHOD2(DeleteBuffersARB, void(GLsizei n, const GLuint* buffers)); MOCK_METHOD2(DeleteFencesAPPLE, void(GLsizei n, const GLuint* fences)); MOCK_METHOD2(DeleteFencesNV, void(GLsizei n, const GLuint* fences)); @@ -314,6 +330,15 @@ MOCK_METHOD2(GetAttribLocation, GLint(GLuint program, const char* name)); MOCK_METHOD2(GetBooleanv, void(GLenum pname, GLboolean* params)); MOCK_METHOD3(GetBufferParameteriv, void(GLenum target, GLenum pname, GLint* params)); +MOCK_METHOD8(GetDebugMessageLogKHR, + GLuint(GLuint count, + GLsizei bufSize, + GLenum* sources, + GLenum* types, + GLuint* ids, + GLenum* severities, + GLsizei* lengths, + GLchar* messageLog)); MOCK_METHOD0(GetError, GLenum()); MOCK_METHOD3(GetFenceivNV, void(GLuint fence, GLenum pname, GLint* params)); MOCK_METHOD2(GetFloatv, void(GLenum pname, GLfloat* params)); @@ -451,10 +476,14 @@ MOCK_METHOD4(MapBufferRange, GLbitfield access)); MOCK_METHOD2(MatrixLoadfEXT, void(GLenum matrixMode, const GLfloat* m)); MOCK_METHOD1(MatrixLoadIdentityEXT, void(GLenum matrixMode)); +MOCK_METHOD4( + ObjectLabelKHR, + void(GLenum identifier, GLuint name, GLsizei length, const GLchar* label)); MOCK_METHOD0(PauseTransformFeedback, void()); MOCK_METHOD2(PixelStorei, void(GLenum pname, GLint param)); MOCK_METHOD2(PointParameteri, void(GLenum pname, GLint param)); MOCK_METHOD2(PolygonOffset, void(GLfloat factor, GLfloat units)); +MOCK_METHOD0(PopDebugGroupKHR, void()); MOCK_METHOD0(PopGroupMarkerEXT, void()); MOCK_METHOD4(ProgramBinary, void(GLuint program, @@ -463,6 +492,9 @@ MOCK_METHOD4(ProgramBinary, GLsizei length)); MOCK_METHOD3(ProgramParameteri, void(GLuint program, GLenum pname, GLint value)); +MOCK_METHOD4( + PushDebugGroupKHR, + void(GLenum source, GLuint id, GLsizei length, const GLchar* message)); MOCK_METHOD2(PushGroupMarkerEXT, void(GLsizei length, const char* marker)); MOCK_METHOD2(QueryCounter, void(GLuint id, GLenum target)); MOCK_METHOD1(ReadBuffer, void(GLenum src)); From 50eac9559adebaae259047536a4eb855542cc1cb Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Tue, 21 Jul 2015 13:46:10 -0700 Subject: [PATCH 04/11] Separate width and height parameters for Image widgets This change makes it easier to defined only the width or the height of an image and let the other value be filled in from the image's intrinsic aspect ratio. Fixes #175 --- .../example/rendering/interactive_flex.dart | 8 +-- sky/sdk/example/widgets/container.dart | 3 +- sky/sdk/lib/rendering/box.dart | 58 +++++++++++-------- sky/sdk/lib/widgets/basic.dart | 44 +++++++++----- sky/sdk/lib/widgets/icon.dart | 3 +- 5 files changed, 69 insertions(+), 47 deletions(-) diff --git a/sky/sdk/example/rendering/interactive_flex.dart b/sky/sdk/example/rendering/interactive_flex.dart index 24f6f605a08..940aacfc7fc 100644 --- a/sky/sdk/example/rendering/interactive_flex.dart +++ b/sky/sdk/example/rendering/interactive_flex.dart @@ -25,15 +25,15 @@ class Touch { class RenderImageGrow extends RenderImage { final Size _startingSize; - RenderImageGrow(Image image, Size size) : _startingSize = size, super(image, size); + RenderImageGrow(Image image, Size size) + : _startingSize = size, super(image: image, width: size.width, height: size.height); double _growth = 0.0; double get growth => _growth; void set growth(double value) { _growth = value; - double newWidth = _startingSize.width == null ? null : _startingSize.width + growth; - double newHeight = _startingSize.height == null ? null : _startingSize.height + growth; - requestedSize = new Size(newWidth, newHeight); + width = _startingSize.width == null ? null : _startingSize.width + growth; + height = _startingSize.height == null ? null : _startingSize.height + growth; } } diff --git a/sky/sdk/example/widgets/container.dart b/sky/sdk/example/widgets/container.dart index 9ebea3aa668..836d731fa48 100644 --- a/sky/sdk/example/widgets/container.dart +++ b/sky/sdk/example/widgets/container.dart @@ -16,7 +16,8 @@ class ContainerApp extends App { decoration: new BoxDecoration(backgroundColor: const Color(0xFFCCCCCC)), child: new NetworkImage( src: "https://www.dartlang.org/logos/dart-logo.png", - size: new Size(300.0, 300.0) + width: 300.0, + height: 300.0 ) ), new Container( diff --git a/sky/sdk/lib/rendering/box.dart b/sky/sdk/lib/rendering/box.dart index 5f6142a555d..eafd40d1e15 100644 --- a/sky/sdk/lib/rendering/box.dart +++ b/sky/sdk/lib/rendering/box.dart @@ -1249,9 +1249,10 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin _requestedSize; - void set requestedSize (Size value) { - if (value == null) - value = const Size(null, null); - if (value == _requestedSize) + double _width; + double get width => _width; + void set width (double value) { + if (value == _width) return; - _requestedSize = value; + _width = value; + markNeedsLayout(); + } + + double _height; + double get height => _height; + void set height (double value) { + if (value == _height) + return; + _height = value; markNeedsLayout(); } @@ -1299,8 +1307,8 @@ class RenderImage extends RenderBox { Size _sizeForConstraints(BoxConstraints constraints) { // If there's no image, we can't size ourselves automatically if (_image == null) { - double width = requestedSize.width == null ? 0.0 : requestedSize.width; - double height = requestedSize.height == null ? 0.0 : requestedSize.height; + double width = _width == null ? 0.0 : _width; + double height = _height == null ? 0.0 : _height; return constraints.constrain(new Size(width, height)); } @@ -1310,8 +1318,8 @@ class RenderImage extends RenderBox { // other dimension to maintain the aspect ratio. In both cases, // constrain dimensions first, otherwise we end up losing the // ratio after constraining. - if (requestedSize.width == null) { - if (requestedSize.height == null) { + if (_width == null) { + if (_height == null) { // autosize double width = constraints.constrainWidth(_image.width.toDouble()); double maxHeight = constraints.constrainHeight(_image.height.toDouble()); @@ -1323,21 +1331,21 @@ class RenderImage extends RenderBox { } return constraints.constrain(new Size(width, height)); } - // determine width from height - double width = requestedSize.height * _image.width / _image.height; - return constraints.constrain(new Size(width, requestedSize.height)); + // Determine width from height + double width = _height * _image.width / _image.height; + return constraints.constrain(new Size(width, height)); } - if (requestedSize.height == null) { - // determine height from width - double height = requestedSize.width * _image.height / _image.width; - return constraints.constrain(new Size(requestedSize.width, height)); + if (_height == null) { + // Determine height from width + double height = _width * _image.height / _image.width; + return constraints.constrain(new Size(width, height)); } } - return constraints.constrain(requestedSize); + return constraints.constrain(new Size(width, height)); } double getMinIntrinsicWidth(BoxConstraints constraints) { - if (requestedSize.width == null && requestedSize.height == null) + if (_width == null && _height == null) return constraints.constrainWidth(0.0); return _sizeForConstraints(constraints).width; } @@ -1347,7 +1355,7 @@ class RenderImage extends RenderBox { } double getMinIntrinsicHeight(BoxConstraints constraints) { - if (requestedSize.width == null && requestedSize.height == null) + if (_width == null && _height == null) return constraints.constrainHeight(0.0); return _sizeForConstraints(constraints).height; } @@ -1377,7 +1385,7 @@ class RenderImage extends RenderBox { canvas.restore(); } - String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}dimensions: ${requestedSize}\n'; + String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}width: ${width}\n${prefix}height: ${height}\n'; } class RenderDecoratedBox extends RenderProxyBox { diff --git a/sky/sdk/lib/widgets/basic.dart b/sky/sdk/lib/widgets/basic.dart index 29521687e5d..8e3e8f78667 100644 --- a/sky/sdk/lib/widgets/basic.dart +++ b/sky/sdk/lib/widgets/basic.dart @@ -488,31 +488,34 @@ class Text extends Component { } class Image extends LeafRenderObjectWrapper { - Image({ sky.Image image, this.size, this.colorFilter }) + Image({ sky.Image image, this.width, this.height, this.colorFilter }) : image = image, super(key: image.hashCode.toString()); // TODO(ianh): Find a way to uniquely identify the sky.Image rather than using hashCode, which could collide final sky.Image image; - final Size size; + final double width; + final double height; final sky.ColorFilter colorFilter; - RenderImage createNode() => new RenderImage(image, size, colorFilter: colorFilter); + RenderImage createNode() => new RenderImage(image: image, width: width, height: height, colorFilter: colorFilter); RenderImage get root => super.root; void syncRenderObject(Widget old) { super.syncRenderObject(old); root.image = image; - root.requestedSize = size; + root.width = width; + root.height = height; root.colorFilter = colorFilter; } } class FutureImage extends StatefulComponent { - FutureImage({ String key, this.image, this.size, this.colorFilter }) + FutureImage({ String key, this.image, this.width, this.height, this.colorFilter }) : super(key: key); Future image; - Size size; + double width; + double height; sky.ColorFilter colorFilter; sky.Image _resolvedImage; @@ -535,48 +538,57 @@ class FutureImage extends StatefulComponent { void syncFields(FutureImage source) { bool needToResolveImage = (image != source.image); image = source.image; - size = source.size; + width = source.width; + height = source.height; if (needToResolveImage) _resolveImage(); } Widget build() { - return new Image(image: _resolvedImage, size: size, colorFilter: colorFilter); + return new Image( + image: _resolvedImage, + width: width, + height: height, + colorFilter: colorFilter + ); } } class NetworkImage extends Component { - NetworkImage({ String src, this.size, this.colorFilter }) - : src = src, - super(key: src); + NetworkImage({ String src, this.width, this.height, this.colorFilter }) + : src = src, super(key: src); final String src; - final Size size; + final double width; + final double height; final sky.ColorFilter colorFilter; Widget build() { return new FutureImage( image: image_cache.load(src), - size: size, + width: width, + height: height, colorFilter: colorFilter ); } } class AssetImage extends Component { - AssetImage({ String name, this.bundle, this.size, this.colorFilter }) + AssetImage({ String name, this.bundle, this.width, this.height, this.colorFilter }) : name = name, super(key: name); final String name; final AssetBundle bundle; - final Size size; + final double width; + final double height; final sky.ColorFilter colorFilter; Widget build() { return new FutureImage( image: bundle.loadImage(name), - size: size, + width: width, + height: height, colorFilter: colorFilter ); } diff --git a/sky/sdk/lib/widgets/icon.dart b/sky/sdk/lib/widgets/icon.dart index 7229d9e17f0..c460228c81a 100644 --- a/sky/sdk/lib/widgets/icon.dart +++ b/sky/sdk/lib/widgets/icon.dart @@ -93,7 +93,8 @@ class Icon extends Component { return new AssetImage( bundle: _iconBundle, name: '${category}/${density}/ic_${subtype}_${colorSuffix}_${size}dp.png', - size: new Size(size.toDouble(), size.toDouble()), + width: size.toDouble(), + height: size.toDouble(), colorFilter: colorFilter ); } From b8d45ce91e011b908b620ef09db51e1379496e20 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Tue, 21 Jul 2015 13:51:27 -0700 Subject: [PATCH 05/11] Fix analyzer warnings --- sky/sdk/example/fitness/lib/home.dart | 1 - sky/sdk/example/fitness/lib/measurement.dart | 1 - sky/sdk/example/raw/mutating-dom.dart | 17 +++++++++-------- sky/sdk/example/rendering/align_items.dart | 4 ++-- sky/sdk/example/widgets/card_collection.dart | 2 +- 5 files changed, 12 insertions(+), 13 deletions(-) diff --git a/sky/sdk/example/fitness/lib/home.dart b/sky/sdk/example/fitness/lib/home.dart index df616c7cba3..515c4135058 100644 --- a/sky/sdk/example/fitness/lib/home.dart +++ b/sky/sdk/example/fitness/lib/home.dart @@ -14,7 +14,6 @@ import 'package:sky/widgets/drawer_item.dart'; import 'package:sky/widgets/floating_action_button.dart'; import 'package:sky/widgets/icon_button.dart'; import 'package:sky/widgets/icon.dart'; -import 'package:sky/widgets/ink_well.dart'; import 'package:sky/widgets/material.dart'; import 'package:sky/widgets/navigator.dart'; import 'package:sky/widgets/scaffold.dart'; diff --git a/sky/sdk/example/fitness/lib/measurement.dart b/sky/sdk/example/fitness/lib/measurement.dart index 6487fd50150..c7913388d4c 100644 --- a/sky/sdk/example/fitness/lib/measurement.dart +++ b/sky/sdk/example/fitness/lib/measurement.dart @@ -4,7 +4,6 @@ import 'package:sky/editing/input.dart'; import 'package:sky/widgets/basic.dart'; -import 'package:sky/widgets/flat_button.dart'; import 'package:sky/widgets/icon_button.dart'; import 'package:sky/widgets/ink_well.dart'; import 'package:sky/widgets/material.dart'; diff --git a/sky/sdk/example/raw/mutating-dom.dart b/sky/sdk/example/raw/mutating-dom.dart index f157e47fb2e..0d27a3f0086 100644 --- a/sky/sdk/example/raw/mutating-dom.dart +++ b/sky/sdk/example/raw/mutating-dom.dart @@ -148,26 +148,27 @@ void doFrame(double timeStamp) { break; } } else { - assert(node is sky.Text); // + assert(node is sky.Text); // + final sky.Text text = node; if (pickThis(0.1)) { report("appending a new text node (ASCII)"); - node.appendData(generateCharacter(0x20, 0x7F)); + text.appendData(generateCharacter(0x20, 0x7F)); break; } else if (pickThis(0.05)) { report("appending a new text node (Latin1)"); - node.appendData(generateCharacter(0x20, 0xFF)); + text.appendData(generateCharacter(0x20, 0xFF)); break; } else if (pickThis(0.025)) { report("appending a new text node (BMP)"); - node.appendData(generateCharacter(0x20, 0xFFFF)); + text.appendData(generateCharacter(0x20, 0xFFFF)); break; } else if (pickThis(0.0125)) { report("appending a new text node (Unicode)"); - node.appendData(generateCharacter(0x20, 0x10FFFF)); + text.appendData(generateCharacter(0x20, 0x10FFFF)); break; - } else if (node.length > 1 && pickThis(0.1)) { + } else if (text.length > 1 && pickThis(0.1)) { report("deleting character from Text node"); - node.deleteData(random.nextInt(node.length), 1); + text.deleteData(random.nextInt(text.length), 1); break; } } @@ -178,7 +179,7 @@ void doFrame(double timeStamp) { int count = 1; while (node != null) { if (node is sky.Element && node.firstChild != null) { - node = node.firstChild; + node = (node as sky.Element).firstChild; count += 1; } else { while (node != null && node.nextSibling == null) diff --git a/sky/sdk/example/rendering/align_items.dart b/sky/sdk/example/rendering/align_items.dart index 5a9c247fc8d..58d000468d0 100644 --- a/sky/sdk/example/rendering/align_items.dart +++ b/sky/sdk/example/rendering/align_items.dart @@ -20,7 +20,7 @@ void main() { TextStyle style = const TextStyle(color: const Color(0xFF000000)); RenderParagraph paragraph = new RenderParagraph(new InlineStyle(style, [new InlineText("${alignItems}")])); table.add(new RenderPadding(child: paragraph, padding: new EdgeDims.only(top: 20.0))); - var row = new RenderFlex(alignItems: alignItems, baseline: TextBaseline.alphabetic); + var row = new RenderFlex(alignItems: alignItems, textBaseline: TextBaseline.alphabetic); style = new TextStyle(fontSize: 15.0, color: const Color(0xFF000000)); row.add(new RenderDecoratedBox( @@ -32,7 +32,7 @@ void main() { decoration: new BoxDecoration(backgroundColor: const Color(0x7FCCFFCC)), child: new RenderParagraph(new InlineStyle(style, [new InlineText('foo foo foo')])) )); - var subrow = new RenderFlex(alignItems: alignItems, baseline: TextBaseline.alphabetic); + var subrow = new RenderFlex(alignItems: alignItems, textBaseline: TextBaseline.alphabetic); style = new TextStyle(fontSize: 25.0, color: const Color(0xFF000000)); subrow.add(new RenderDecoratedBox( decoration: new BoxDecoration(backgroundColor: const Color(0x7FCCCCFF)), diff --git a/sky/sdk/example/widgets/card_collection.dart b/sky/sdk/example/widgets/card_collection.dart index 6725e372e1a..0aab3cb7e71 100644 --- a/sky/sdk/example/widgets/card_collection.dart +++ b/sky/sdk/example/widgets/card_collection.dart @@ -44,7 +44,7 @@ class ShrinkingCard extends AnimatedComponent { Function onUpdated; Function onCompleted; - double get currentHeight => card.performance.variable.value; + double get currentHeight => (card.performance.variable as AnimatedType).value; void initState() { assert(card.performance != null); From a43a34e901e8f3daab89bbc366deb79ba5bb20e1 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Tue, 21 Jul 2015 13:59:18 -0700 Subject: [PATCH 06/11] Fix more analyzer warnings --- sky/sdk/example/widgets/card_collection.dart | 2 +- sky/sdk/lib/rendering/flex.dart | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/sky/sdk/example/widgets/card_collection.dart b/sky/sdk/example/widgets/card_collection.dart index eb79bb416d5..609993114af 100644 --- a/sky/sdk/example/widgets/card_collection.dart +++ b/sky/sdk/example/widgets/card_collection.dart @@ -45,7 +45,7 @@ class ShrinkingCard extends AnimatedComponent { Function onUpdated; Function onCompleted; - double get currentHeight => (card.performance.variable as AnimatedType).value; + double get currentHeight => (card.performance.variable as AnimatedValue).value; void initState() { assert(card.performance != null); diff --git a/sky/sdk/lib/rendering/flex.dart b/sky/sdk/lib/rendering/flex.dart index d36afe074a5..8b61489dfb4 100644 --- a/sky/sdk/lib/rendering/flex.dart +++ b/sky/sdk/lib/rendering/flex.dart @@ -93,6 +93,7 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin Date: Tue, 21 Jul 2015 14:38:44 -0700 Subject: [PATCH 07/11] Images don't appears in VariableHeightScrollables When we build widgets during layout we weren't notifying those widgets that they were mounted. Now we notify mount status changes when exiting build phases inside layout. Fixes #176 --- .../widgets/variable_height_scrollable.dart | 2 ++ sky/sdk/lib/widgets/widget.dart | 20 ++++++++++--------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/sky/sdk/lib/widgets/variable_height_scrollable.dart b/sky/sdk/lib/widgets/variable_height_scrollable.dart index 7799d913b22..66f060f85df 100644 --- a/sky/sdk/lib/widgets/variable_height_scrollable.dart +++ b/sky/sdk/lib/widgets/variable_height_scrollable.dart @@ -8,6 +8,8 @@ import 'package:sky/widgets/block_viewport.dart'; import 'package:sky/widgets/scrollable.dart'; import 'package:sky/widgets/widget.dart'; +export 'package:sky/widgets/block_viewport.dart' show BlockViewportLayoutState; + class VariableHeightScrollable extends Scrollable { VariableHeightScrollable({ String key, diff --git a/sky/sdk/lib/widgets/widget.dart b/sky/sdk/lib/widgets/widget.dart index 637f39084f0..6f96239056c 100644 --- a/sky/sdk/lib/widgets/widget.dart +++ b/sky/sdk/lib/widgets/widget.dart @@ -6,7 +6,6 @@ import 'dart:async'; import 'dart:collection'; import 'dart:sky' as sky; -import 'package:sky/base/debug.dart'; import 'package:sky/base/hit_test.dart'; import 'package:sky/mojo/activity.dart' as activity; import 'package:sky/rendering/box.dart'; @@ -600,17 +599,20 @@ int _inLayoutCallbackBuilder = 0; class LayoutCallbackBuilderHandle { bool _active = true; } LayoutCallbackBuilderHandle enterLayoutCallbackBuilder() { - if (!inDebugBuild) - return null; - _inLayoutCallbackBuilder += 1; + assert(() { + _inLayoutCallbackBuilder += 1; + return true; + }); return new LayoutCallbackBuilderHandle(); } void exitLayoutCallbackBuilder(LayoutCallbackBuilderHandle handle) { - if (!inDebugBuild) - return; - assert(handle._active); - handle._active = false; - _inLayoutCallbackBuilder -= 1; + assert(() { + assert(handle._active); + handle._active = false; + _inLayoutCallbackBuilder -= 1; + return true; + }); + Widget._notifyMountStatusChanged(); } List _debugFrameTimes = []; From 24c88827e50125c08eb9405cfdf3ac0b5ef9b443 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Tue, 21 Jul 2015 14:56:54 -0700 Subject: [PATCH 08/11] Roll version to 20 --- sky/sdk/CHANGELOG.md | 4 ++++ sky/sdk/example/demo_launcher/apk/AndroidManifest.xml | 2 +- sky/sdk/example/demo_launcher/apk/release_notes/0.0.20.txt | 1 + sky/sdk/pubspec.yaml | 2 +- 4 files changed, 7 insertions(+), 2 deletions(-) create mode 100644 sky/sdk/example/demo_launcher/apk/release_notes/0.0.20.txt diff --git a/sky/sdk/CHANGELOG.md b/sky/sdk/CHANGELOG.md index 448e203418f..7dd98e6c8a3 100644 --- a/sky/sdk/CHANGELOG.md +++ b/sky/sdk/CHANGELOG.md @@ -1,3 +1,7 @@ +## 0.0.20 + + - 167 changes: https://github.com/domokit/mojo/compare/f2830c7...603f589 + ## 0.0.19 - 49 changes: https://github.com/domokit/mojo/compare/a64559a...1b8968c diff --git a/sky/sdk/example/demo_launcher/apk/AndroidManifest.xml b/sky/sdk/example/demo_launcher/apk/AndroidManifest.xml index a10f9ce99f0..dc14953b956 100644 --- a/sky/sdk/example/demo_launcher/apk/AndroidManifest.xml +++ b/sky/sdk/example/demo_launcher/apk/AndroidManifest.xml @@ -3,7 +3,7 @@ Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. --> - + diff --git a/sky/sdk/example/demo_launcher/apk/release_notes/0.0.20.txt b/sky/sdk/example/demo_launcher/apk/release_notes/0.0.20.txt new file mode 100644 index 00000000000..1deb9ce393f --- /dev/null +++ b/sky/sdk/example/demo_launcher/apk/release_notes/0.0.20.txt @@ -0,0 +1 @@ +Fixes crash on Nexus 6 diff --git a/sky/sdk/pubspec.yaml b/sky/sdk/pubspec.yaml index 89af220a4ea..7ef9c6b8552 100644 --- a/sky/sdk/pubspec.yaml +++ b/sky/sdk/pubspec.yaml @@ -11,4 +11,4 @@ environment: sdk: '>=1.8.0 <2.0.0' homepage: https://github.com/domokit/mojo/tree/master/sky name: sky -version: 0.0.19 +version: 0.0.20 From 761ab683d18735641b2a1117e55adb0404052dc2 Mon Sep 17 00:00:00 2001 From: Hixie Date: Tue, 21 Jul 2015 14:54:03 -0700 Subject: [PATCH 09/11] Rationalise usage of keys in navigator.dart. Route (named routes) no longer have a key, and have their own storage for their names. RouseState no longer has a key, and uses an owner field pointing to a StatefulComponent instead. As such, RouteBase no longer has a key. HistoryEntry no longer uses a global int to ensure uniqueness. Propagated this to stocks app. --- sky/sdk/example/stocks/lib/stock_home.dart | 3 ++- .../example/stocks/lib/stock_settings.dart | 2 +- sky/sdk/lib/widgets/drawer.dart | 3 ++- sky/sdk/lib/widgets/navigator.dart | 25 ++++++++----------- sky/sdk/lib/widgets/popup_menu.dart | 5 ++-- 5 files changed, 19 insertions(+), 19 deletions(-) diff --git a/sky/sdk/example/stocks/lib/stock_home.dart b/sky/sdk/example/stocks/lib/stock_home.dart index b7a8b890262..4ce3187ad60 100644 --- a/sky/sdk/example/stocks/lib/stock_home.dart +++ b/sky/sdk/example/stocks/lib/stock_home.dart @@ -69,7 +69,8 @@ class StockHome extends AnimatedComponent { } void _handleSearchEnd() { - assert(navigator.currentRoute.key == this); + assert(navigator.currentRoute is RouteState); + assert((navigator.currentRoute as RouteState).owner == this); // TODO(ianh): remove cast once analyzer is cleverer navigator.pop(); setState(() { _isSearching = false; diff --git a/sky/sdk/example/stocks/lib/stock_settings.dart b/sky/sdk/example/stocks/lib/stock_settings.dart index a49047c833c..76e5c0389e7 100644 --- a/sky/sdk/example/stocks/lib/stock_settings.dart +++ b/sky/sdk/example/stocks/lib/stock_settings.dart @@ -61,7 +61,7 @@ class StockSettings extends StatefulComponent { break; case StockMode.pessimistic: showModeDialog = true; - navigator.pushState("/settings/confirm", (_) { + navigator.pushState(this, (_) { showModeDialog = false; }); break; diff --git a/sky/sdk/lib/widgets/drawer.dart b/sky/sdk/lib/widgets/drawer.dart index 781970ea1d7..b45aa9f1913 100644 --- a/sky/sdk/lib/widgets/drawer.dart +++ b/sky/sdk/lib/widgets/drawer.dart @@ -143,7 +143,8 @@ class Drawer extends AnimatedComponent { if (_lastStatus != null && status != _lastStatus) { if (status == DrawerStatus.inactive && navigator != null && - navigator.currentRoute.key == this) + navigator.currentRoute is RouteState && + (navigator.currentRoute as RouteState).owner == this) // TODO(ianh): remove cast once analyzer is cleverer navigator.pop(); if (onStatusChanged != null) onStatusChanged(status); diff --git a/sky/sdk/lib/widgets/navigator.dart b/sky/sdk/lib/widgets/navigator.dart index 8254bbef58d..1a20b5aeb4d 100644 --- a/sky/sdk/lib/widgets/navigator.dart +++ b/sky/sdk/lib/widgets/navigator.dart @@ -12,25 +12,24 @@ import 'package:vector_math/vector_math.dart'; typedef Widget Builder(Navigator navigator, RouteBase route); abstract class RouteBase { - RouteBase({ this.key }); - final Object key; Widget build(Navigator navigator, RouteBase route); void popState() { } } class Route extends RouteBase { - Route({ String name, this.builder }) : super(key: name); - String get name => key; + Route({ this.name, this.builder }); + final String name; final Builder builder; Widget build(Navigator navigator, RouteBase route) => builder(navigator, route); } class RouteState extends RouteBase { - RouteState({ this.callback, this.route, Object key }) : super(key: key); + RouteState({ this.callback, this.route, this.owner }); - RouteBase route; Function callback; + RouteBase route; + StatefulComponent owner; Widget build(Navigator navigator, RouteBase route) => null; @@ -144,9 +143,8 @@ class Transition extends AnimatedComponent { } class HistoryEntry { - HistoryEntry({ this.route, this.key }); + HistoryEntry({ this.route }); final RouteBase route; - final int key; bool transitionFinished = false; // TODO(jackson): Keep track of the requested transition } @@ -158,12 +156,11 @@ class NavigationState { if (route.name != null) namedRoutes[route.name] = route; } - history.add(new HistoryEntry(route: routes[0], key: _lastKey++)); + history.add(new HistoryEntry(route: routes[0])); } List history = new List(); int historyIndex = 0; - int _lastKey = 0; Map namedRoutes = new Map(); RouteBase get currentRoute => history[historyIndex].route; @@ -176,7 +173,7 @@ class NavigationState { } void push(RouteBase route) { - HistoryEntry historyEntry = new HistoryEntry(route: route, key: _lastKey++); + HistoryEntry historyEntry = new HistoryEntry(route: route); history.insert(historyIndex + 1, historyEntry); historyIndex++; } @@ -203,9 +200,9 @@ class Navigator extends StatefulComponent { RouteBase get currentRoute => state.currentRoute; - void pushState(Object key, Function callback) { + void pushState(StatefulComponent owner, Function callback) { RouteBase route = new RouteState( - key: key, + owner: owner, callback: callback, route: state.currentRoute ); @@ -245,7 +242,7 @@ class Navigator extends StatefulComponent { if (content == null) continue; Transition transition = new Transition( - key: historyEntry.key.toString(), + key: historyEntry.hashCode.toString(), // TODO(ianh): make it not collide content: content, direction: (i <= state.historyIndex) ? TransitionDirection.forward : TransitionDirection.reverse, interactive: (i == state.historyIndex), diff --git a/sky/sdk/lib/widgets/popup_menu.dart b/sky/sdk/lib/widgets/popup_menu.dart index 85e9bd70c64..49d6aa97b86 100644 --- a/sky/sdk/lib/widgets/popup_menu.dart +++ b/sky/sdk/lib/widgets/popup_menu.dart @@ -122,8 +122,9 @@ class PopupMenu extends AnimatedComponent { PopupMenuStatus status = _status; if (_lastStatus != null && status != _lastStatus) { if (status == PopupMenuStatus.inactive && - navigator != null && - navigator.currentRoute.key == this) + navigator != null && + navigator.currentRoute is RouteState && + (navigator.currentRoute as RouteState).owner == this) // TODO(ianh): remove cast once analyzer is cleverer navigator.pop(); if (onStatusChanged != null) onStatusChanged(status); From a058bc47ffa3d42077896f4e04c944e1c033b829 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Tue, 21 Jul 2015 15:10:29 -0700 Subject: [PATCH 10/11] Remove hard-coded default paths ... and move instructions to the wiki. --- sky/tools/big_red_button.py | 25 ++++++------------------- 1 file changed, 6 insertions(+), 19 deletions(-) diff --git a/sky/tools/big_red_button.py b/sky/tools/big_red_button.py index ba110f58509..0f04d2b3965 100755 --- a/sky/tools/big_red_button.py +++ b/sky/tools/big_red_button.py @@ -3,14 +3,7 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. -# Prepare release script. -# -# 1) Bump versions using sky/tools/roll_versions.py -# 2) Add any additional information to touched CHANGELOG.md files. -# 3) Add any release_notes/version.txt files for updated apks. -# 4) Make a commit, upload it, land it. -# 5) Run this script. -# 6) Publish updated apks using sky/tools/publish_apk.py +# See https://github.com/domokit/sky_engine/wiki/Release-process import argparse import os @@ -19,9 +12,6 @@ import sys import distutils.util -DEFAULT_SKY_ENGINE_ROOT = '/src/sky_engine/src' -DEFAULT_SKY_SDK_ROOT = '/src/sky_sdk' -DEFAULT_DEMO_SITE_ROOT = '/src/domokit.github.io' CONFIRM_MESSAGE = """This tool is destructive and will revert your current branch to origin/master among other things. Are you sure you wish to continue?""" DRY_RUN = False @@ -44,12 +34,9 @@ def confirm(prompt): def main(): parser = argparse.ArgumentParser(description='Deploy!') - parser.add_argument('--sky-engine-root', help='Path to sky_engine/src', - default=DEFAULT_SKY_ENGINE_ROOT) - parser.add_argument('--sky-sdk-root', help='Path to sky_sdk', - default=DEFAULT_SKY_SDK_ROOT) - parser.add_argument('--demo-site-root', help='Path to domokit.github.io', - default=DEFAULT_DEMO_SITE_ROOT) + parser.add_argument('sky_engine_root', help='Path to sky_engine/src') + parser.add_argument('sky_sdk_root', help='Path to sky_sdk') + parser.add_argument('demo_site_root', help='Path to domokit.github.io') parser.add_argument('--dry-run', action='store_true', default=False, help='Just print commands w/o executing.') parser.add_argument('--no-pub-publish', dest='publish', @@ -80,7 +67,7 @@ def main(): # Run tests? run(sky_sdk_root, ['git', 'fetch']) - run(sky_sdk_root, ['git', 'reset', '--hard', 'origin/master']) + run(sky_sdk_root, ['git', 'reset', '--hard', 'upstream/master']) run(sky_engine_root, [ 'sky/tools/deploy_sdk.py', '--non-interactive', @@ -89,7 +76,7 @@ def main(): # tag for version? run(demo_site_root, ['git', 'fetch']) - run(demo_site_root, ['git', 'reset', '--hard', 'origin/master']) + run(demo_site_root, ['git', 'reset', '--hard', 'upstream/master']) # TODO(eseidel): We should move this script back into sky/tools. run(sky_engine_root, ['mojo/tools/deploy_domokit_site.py', demo_site_root]) # tag for version? From 5e6d9d6bb57b4b132c617dfc899627e0a57285aa Mon Sep 17 00:00:00 2001 From: Hixie Date: Tue, 21 Jul 2015 15:13:01 -0700 Subject: [PATCH 11/11] Remove redundant operator== and hashCode functions in card example. It turns out that we aren't really using these. The identity logic is sufficient. Also, add some asserts for a crash I had once but couldn't reproduce, in case that helps catch it next time. --- sky/sdk/example/widgets/card_collection.dart | 2 -- sky/sdk/lib/animation/timeline.dart | 3 ++- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/sky/sdk/example/widgets/card_collection.dart b/sky/sdk/example/widgets/card_collection.dart index 609993114af..c3b7cb2fadb 100644 --- a/sky/sdk/example/widgets/card_collection.dart +++ b/sky/sdk/example/widgets/card_collection.dart @@ -28,8 +28,6 @@ class CardModel { AnimationPerformance performance; String get label => "Item $value"; String get key => value.toString(); - bool operator ==(other) => other is CardModel && other.value == value; - int get hashCode => 373 * 37 * value.hashCode; } class ShrinkingCard extends AnimatedComponent { diff --git a/sky/sdk/lib/animation/timeline.dart b/sky/sdk/lib/animation/timeline.dart index 680130d76bc..1ea2039993f 100644 --- a/sky/sdk/lib/animation/timeline.dart +++ b/sky/sdk/lib/animation/timeline.dart @@ -54,11 +54,12 @@ class Timeline { double end: 1.0 }) { assert(!_animation.isAnimating); - + assert(duration > Duration.ZERO); return _animation.start(new TweenSimulation(duration, begin, end)); } Future animateTo(double target, { Duration duration }) { + assert(duration > Duration.ZERO); return _start(duration: duration, begin: value, end: target); }