commit c5cdddbeaa2efe9e8e097adea8ef8770ce1368ab Author: gered Date: Thu Jan 31 12:53:05 2013 -0500 initial commit current versions of all of my basic framework sources, build configurations/scripts, and supporting assets diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..259b90d --- /dev/null +++ b/.gitignore @@ -0,0 +1,19 @@ +.DS_Store +*.sdf +*.opensdf +*.user +*.suo +*.vpwhistu +*.vtg +*.vpj +*.vpw +/*.exe +/*.idb +/*.ilk +/*.pdb +/*.dll +/*.log +/stdout.txt +/stderr.txt +/enginetest +/build diff --git a/assets/fonts/dlxfont.ttf b/assets/fonts/dlxfont.ttf new file mode 100644 index 0000000..61add23 Binary files /dev/null and b/assets/fonts/dlxfont.ttf differ diff --git a/assets/ui_skin.png b/assets/ui_skin.png new file mode 100644 index 0000000..9fba727 Binary files /dev/null and b/assets/ui_skin.png differ diff --git a/generate_makefile b/generate_makefile new file mode 100644 index 0000000..ae1b64a --- /dev/null +++ b/generate_makefile @@ -0,0 +1,4 @@ +#!/bin/sh +cd "$(dirname "$0")" +type premake4 >/dev/null 2>&1 || { echo >&2 "'premake4' not found in your path."; exit 1; } +premake4 --file=premake.lua gmake diff --git a/generate_vs2010.bat b/generate_vs2010.bat new file mode 100644 index 0000000..9538990 --- /dev/null +++ b/generate_vs2010.bat @@ -0,0 +1,8 @@ +@echo off +for %%X in (premake4.exe) do (set FOUND=%%~$PATH:X) +if not defined FOUND ( +echo 'premake4' not found in your path. +exit /b +) + +premake4 --file=premake.lua vs2010 diff --git a/generate_xcode b/generate_xcode new file mode 100644 index 0000000..a9d7a31 --- /dev/null +++ b/generate_xcode @@ -0,0 +1,4 @@ +#!/bin/sh +cd "$(dirname "$0")" +type premake4 >/dev/null 2>&1 || { echo >&2 "'premake4' not found in your path."; exit 1; } +premake4 --file=premake.lua xcode4 diff --git a/lib/eastl/eastl_basic_funcs.cpp b/lib/eastl/eastl_basic_funcs.cpp new file mode 100644 index 0000000..f91756e --- /dev/null +++ b/lib/eastl/eastl_basic_funcs.cpp @@ -0,0 +1,37 @@ +// These are very simple, basic, no-frills functions that +// EASTL expects us to create for it to operate. + +// ---- Allocator -------------------------------------------------------------- + +#include +#include // malloc + +void* operator new[](size_t size, const char* pName, int flags, unsigned debugFlags, const char* file, int line) +{ + return malloc(size); +} + +void* operator new[](size_t size, size_t alignment, size_t alignmentOffset, const char* pName, int flags, unsigned debugFlags, const char* file, int line) +{ + // this allocator doesn't support alignment + EASTL_ASSERT(alignment <= 8); + return malloc(size); +} + +// ----------------------------------------------------------------------------- + + +// ---- For strings ------------------------------------------------------------ + +#include + +int Vsnprintf8(char8_t* pDestination, size_t n, const char8_t* pFormat, va_list arguments) +{ +#if defined(_MSC_VER) && !defined(__S3E__) + return _vsnprintf(pDestination, n, pFormat, arguments); +#else + return vsnprintf(pDestination, n, pFormat, arguments); +#endif +} + +// ----------------------------------------------------------------------------- diff --git a/lib/eastl/include/EABase/config/eacompiler.h b/lib/eastl/include/EABase/config/eacompiler.h new file mode 100644 index 0000000..bec777a --- /dev/null +++ b/lib/eastl/include/EABase/config/eacompiler.h @@ -0,0 +1,505 @@ +/* +Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*----------------------------------------------------------------------------- + * config/eacompiler.h + * + * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. + * Maintained by Paul Pedriana, Maxis + * + * Modified to support Clang++ (v2.8) by Austin Seipp, 2010. + * + *----------------------------------------------------------------------------- + * Currently supported defines include: + * EA_COMPILER_GNUC + * EA_COMPILER_CLANG + * EA_COMPILER_ARM + * EA_COMPILER_EDG + * EA_COMPILER_SN + * EA_COMPILER_MSVC + * EA_COMPILER_METROWERKS + * EA_COMPILER_INTEL + * EA_COMPILER_BORLANDC + * EA_COMPILER_IBM + * + * EA_COMPILER_VERSION = + * EA_COMPILER_NAME = + * EA_COMPILER_STRING = + * + * EA_COMPILER_NO_STATIC_CONSTANTS + * EA_COMPILER_NO_TEMPLATE_SPECIALIZATION + * EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION + * EA_COMPILER_NO_MEMBER_TEMPLATES + * EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION + * EA_COMPILER_NO_TEMPLATE_TEMPLATES + * EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS + * EA_COMPILER_NO_VOID_RETURNS + * EA_COMPILER_NO_COVARIANT_RETURN_TYPE + * EA_COMPILER_NO_DEDUCED_TYPENAME + * EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP + * EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE + * EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS + * EA_COMPILER_NO_RTTI + * EA_COMPILER_NO_EXCEPTIONS + * EA_COMPILER_NO_UNWIND + * EA_COMPILER_NO_STANDARD_CPP_LIBRARY + * EA_COMPILER_NO_STATIC_VARIABLE_INIT + * EA_COMPILER_NO_STATIC_FUNCTION_INIT + * + *----------------------------------------------------------------------------- + * + * Documentation + * EA_COMPILER_NO_STATIC_CONSTANTS + * Code such as this is legal, but some compilers fail to compile it: + * struct A{ static const a = 1; }; + * + * EA_COMPILER_NO_TEMPLATE_SPECIALIZATION + * Some compilers fail to allow template specialization, such as with this: + * template void DoSomething(U u); + * void DoSomething(int x); + * + * EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION + * Some compilers fail to allow partial template specialization, such as with this: + * template class vector{ }; // Primary templated class. + * template class vector{ }; // Partially specialized version. + * + * EA_COMPILER_NO_MEMBER_TEMPLATES + * Some compilers fail to allow member template functions such as this: + * struct A{ template void DoSomething(U u); }; + * + * EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION + * Some compilers fail to allow member template specialization, such as with this: + * struct A{ + * template void DoSomething(U u); + * void DoSomething(int x); + * }; + * + * EA_COMPILER_NO_TEMPLATE_TEMPLATES + * Code such as this is legal: + * template class U> + * U SomeFunction(const U x) { return x.DoSomething(); } + * + * EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS + * Some compilers fail to compile templated friends, as with this: + * struct A{ template friend class SomeFriend; }; + * This is described in the C++ Standard at 14.5.3. + * + * EA_COMPILER_NO_VOID_RETURNS + * This is legal C++: + * void DoNothing1(){ }; + * void DoNothing2(){ return DoNothing1(); } + * + * EA_COMPILER_NO_COVARIANT_RETURN_TYPE + * See the C++ standard sec 10.3,p5. + * + * EA_COMPILER_NO_DEDUCED_TYPENAME + * Some compilers don't support the use of 'typename' for + * dependent types in deduced contexts, as with this: + * template void Function(T, typename T::type); + * + * EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP + * Also known as Koenig lookup. Basically, if you have a function + * that is a namespace and you call that function without prefixing + * it with the namespace the compiler should look at any arguments + * you pass to that function call and search their namespace *first* + * to see if the given function exists there. + * + * EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE + * is in namespace std. Some std libraries fail to + * put the contents of in namespace std. The following + * code should normally be legal: + * void Function(){ std::terminate(); } + * + * EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS + * Some compilers fail to execute DoSomething() properly, though they + * succeed in compiling it, as with this: + * template + * bool DoSomething(int j){ return i == j; }; + * DoSomething<1>(2); + * + * EA_COMPILER_NO_EXCEPTIONS + * The compiler is configured to disallow the use of try/throw/catch + * syntax (often to improve performance). Use of such syntax in this + * case will cause a compilation error. + * + * EA_COMPILER_NO_UNWIND + * The compiler is configured to allow the use of try/throw/catch + * syntax and behaviour but disables the generation of stack unwinding + * code for responding to exceptions (often to improve performance). + * + *---------------------------------------------------------------------------*/ + +#ifndef INCLUDED_eacompiler_H +#define INCLUDED_eacompiler_H + +#ifndef INCLUDED_eaplatform_H +# include "EABase/config/eaplatform.h" +#endif + + // Note: This is used to generate the EA_COMPILER_STRING macros +#ifndef INTERNAL_STRINGIZE +# define INTERNAL_STRINGIZE(x) INTERNAL_PRIMITIVE_STRINGIZE(x) +#endif +#ifndef INTERNAL_PRIMITIVE_STRINGIZE +# define INTERNAL_PRIMITIVE_STRINGIZE(x) #x +#endif + + // Note: this is for compatibility with non-clang compilers +#ifndef __has_feature +# define __has_feature(x) 0 +#endif + + // Note: this is for compatibility with non-clang compilers +#ifndef __has_attribute +# define __has_attribute(x) 0 +#endif + + // Note: this is for compatibility with non-clang compilers +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif + + // EDG (EDG compiler front-end, used by other compilers such as SN) +#if defined(__EDG_VERSION__) +# define EA_COMPILER_EDG +#endif + + + // SN +#if defined(__SNC__) // SN Systems compiler + // Note that there are two versions of the SN compiler, one that is + // GNUC-based and a newer one which is based on an EDG (Edison Design + // Group) front-end with a back-end code generator made by SN. + // The EDG-based SN compiler uses "GCC compatibility mode" and thus + // defines __GNUC__ but isn't really GNUC. Also, as of this writing + // it appears that the SN compiler may arrive with MSVC-compatibility + // mode in addition as well. Thus, we define EA_COMPILER_SN + // separately from other EA_COMPILER defines it is possible that both + // may be defined at the same time. Note that while the newer EDG-based + // SN compiler may emulate other compilers, it doesn't act exactly + // the same. +# define EA_COMPILER_SN +#endif + + + // Airplay SDK (third party mobile middleware compiler) +#if defined(__S3E__) +# define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE +#endif + + + // SNC (SN Systems) +#if defined(__SNC__) +# define EA_COMPILER_NAME "SNC" + +# ifdef __GNUC__ // If SN is using GCC-compatibility mode (which it usually is)... +# define EA_COMPILER_GNUC +# define EA_COMPILER_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) // We intentionally report the GCC version here. SN +# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, GCC version " INTERNAL_STRINGIZE( __GNUC__ ) "." INTERNAL_STRINGIZE( __GNUC_MINOR__ ) ", SNC version " INTERNAL_STRINGIZE( __SN_VER__ ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) +# else +# define EA_COMPILER_VERSION __SN_VER__ +# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) +# endif + + // GCC (a.k.a. GNUC) +#elif defined(__GNUC__) // GCC compilers exist for many platforms. +# define EA_COMPILER_GNUC +# define EA_COMPILER_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) +# define EA_COMPILER_NAME "GCC" +# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( __GNUC__ ) "." INTERNAL_STRINGIZE( __GNUC_MINOR__ ) + +# if (__GNUC__ == 2) && (__GNUC_MINOR__ < 95) // If GCC < 2.95... +# define EA_COMPILER_NO_MEMBER_TEMPLATES +# endif +# if (__GNUC__ == 2) && (__GNUC_MINOR__ <= 97) // If GCC <= 2.97... +# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS +# endif +# if (__GNUC__ == 3) && ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2)) // If GCC 3.1 or 3.2 (but not pre 3.1 or post 3.2)... +# define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +# endif + + // Clang (quite compatible with GCC) +#elif defined(__clang__) +# define EA_COMPILER_CLANG +# define EA_COMPILER_VERSION (__clang_major__ * 1000 + __clang_minor__) +# define EA_COMPILER_NAME "Clang++" +# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( __clang_version__ ) + + // Borland C++ +#elif defined(__BORLANDC__) +# define EA_COMPILER_BORLANDC +# define EA_COMPILER_VERSION __BORLANDC__ +# define EA_COMPILER_NAME "Borland C" + //#define EA_COMPILER_STRING (defined below) + +# if (__BORLANDC__ <= 0x0550) // If Borland C++ Builder 4 and 5... +# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS +# endif +# if (__BORLANDC__ >= 0x561) && (__BORLANDC__ < 0x600) +# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION +# endif + + + // Intel C++ (via EDG front-end) +#elif defined(__ICL) || defined(__ICC) +# define EA_COMPILER_INTEL +# if defined(__ICL) +# define EA_COMPILER_VERSION __ICL +# elif defined(__ICC) +# define EA_COMPILER_VERSION __ICC +# endif +# define EA_COMPILER_NAME "Intel C++" + //#define EA_COMPILER_STRING (defined below) + + // Intel is based ont the EDG (Edison Design Group) front end and + // all recent versions are very compliant to the C++ standard. + + + // Metrowerks +#elif defined(__MWERKS__) || defined(__CWCC__) // Metrowerks compilers exist for many platforms. +# define EA_COMPILER_METROWERKS +# ifdef __MWERKS__ +# define EA_COMPILER_VERSION __MWERKS__ +# else +# define EA_COMPILER_VERSION __CWCC__ +# endif +# define EA_COMPILER_NAME "Metrowerks" + //#define EA_COMPILER_STRING (defined below) + +# if (__MWERKS__ <= 0x2407) // If less than v7.x... +# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION +# endif +# if (__MWERKS__ <= 0x3003) // If less than v8.x... +# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS +# endif + + + // Microsoft VC++ +#elif defined(_MSC_VER) && !(defined(__S3E__) && defined(__arm__)) // S3E is a mobile SDK which mistakenly masquerades as VC++ on ARM. +# define EA_COMPILER_MSVC +# define EA_COMPILER_VERSION _MSC_VER +# define EA_COMPILER_NAME "Microsoft Visual C++" + //#define EA_COMPILER_STRING (defined below) + +# if (_MSC_VER <= 1200) // If VC6.x and earlier... +# if (_MSC_VER < 1200) +# define EA_COMPILER_MSVCOLD +# else +# define EA_COMPILER_MSVC6 +# endif + +# if (_MSC_VER < 1200) // If VC5.x or earlier... +# define EA_COMPILER_NO_TEMPLATE_SPECIALIZATION +# endif +# define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS // The compiler compiles this OK, but executes it wrong. Fixed in VC7.0 +# define EA_COMPILER_NO_VOID_RETURNS // The compiler fails to compile such cases. Fixed in VC7.0 +# define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE // The compiler fails to compile such cases. Fixed in VC7.0 +# define EA_COMPILER_NO_DEDUCED_TYPENAME // The compiler fails to compile such cases. Fixed in VC7.0 +# define EA_COMPILER_NO_STATIC_CONSTANTS // The compiler fails to compile such cases. Fixed in VC7.0 +# define EA_COMPILER_NO_COVARIANT_RETURN_TYPE // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 +# define EA_COMPILER_NO_TEMPLATE_TEMPLATES // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS // The compiler fails to compile such cases. Fixed in VC7.1 + //#define EA_COMPILER_NO_MEMBER_TEMPLATES // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%? + //#define EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%? + +# elif (_MSC_VER <= 1300) // If VC7.0 and earlier... +# define EA_COMPILER_MSVC7 + +# define EA_COMPILER_NO_COVARIANT_RETURN_TYPE // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 +# define EA_COMPILER_NO_TEMPLATE_TEMPLATES // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS // The compiler fails to compile such cases. Fixed in VC7.1 +# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION // This is the case only for VC7.0 and not VC6 or VC7.1+. Fixed in VC7.1 + //#define EA_COMPILER_NO_MEMBER_TEMPLATES // VC7.0 supports member templates properly 95% of the time. So do we flag the remaining 5%? + +# elif (_MSC_VER < 1400) // If VC7.1 ... + // The VC7.1 and later compiler is fairly close to the C++ standard + // and thus has no compiler limitations that we are concerned about. +# define EA_COMPILER_MSVC7_2003 +# define EA_COMPILER_MSVC7_1 + +# else // _MSC_VER of 1400 means VC8 (VS2005), 1500 means VC9 (VS2008) +# define EA_COMPILER_MSVC8_2005 +# define EA_COMPILER_MSVC8_0 + +# endif + + + // IBM +#elif defined(__xlC__) +# define EA_COMPILER_IBM +# define EA_COMPILER_NAME "IBM XL C" +# define EA_COMPILER_VERSION __xlC__ +# define EA_COMPILER_STRING "IBM XL C compiler, version " INTERNAL_STRINGIZE( __xlC__ ) + + + // ARM compiler +# if defined(__ARMCC_VERSION) + // Note that this refers to the ARM compiler (armcc or armcpp), but there + // are other compilers that target ARM processors, such as GCC and Microsoft VC++. + // If you want to detect compiling for the ARM processor, check for EA_PROCESSOR_ARM + // being defined. +# define EA_COMPILER_ARM +# define EA_COMPILER_VERSION __ARMCC_VERSION +# define EA_COMPILER_NAME __CC_ARM + //#define EA_COMPILER_STRING (defined below) + +# endif + + + // Unknown +#else // Else the compiler is unknown + +# define EA_COMPILER_VERSION 0 +# define EA_COMPILER_NAME "Unknown" + +#endif + +#ifndef EA_COMPILER_STRING +# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE(EA_COMPILER_VERSION) +#endif + + + // Deprecated definitions + // For backwards compatibility, should be supported for at least the life of EABase v2.0.x. +#ifndef EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# define EA_COMPILER_PARTIAL_TEMPLATE_SPECIALIZATION +#endif +#ifndef EA_COMPILER_NO_TEMPLATE_SPECIALIZATION +# define EA_COMPILER_TEMPLATE_SPECIALIZATION +#endif +#ifndef EA_COMPILER_NO_MEMBER_TEMPLATES +# define EA_COMPILER_MEMBER_TEMPLATES +#endif +#ifndef EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION +# define EA_COMPILER_MEMBER_TEMPLATE_SPECIALIZATION +#endif + + + + // EA_COMPILER_NO_RTTI + // + // If EA_COMPILER_NO_RTTI is defined, then RTTI (run-time type information) + // is not available (possibly due to being disabled by the user). + // +#if defined(__SNC__) && !defined(__RTTI) +# define EA_COMPILER_NO_RTTI +#elif defined(__GXX_ABI_VERSION) && !defined(__GXX_RTTI) +# define EA_COMPILER_NO_RTTI +#elif defined(__clang__) && !__has_feature(cxx_rtti) +# define EA_COMPILER_NO_RTTI +#elif defined(_MSC_VER) && !defined(_CPPRTTI) +# define EA_COMPILER_NO_RTTI +#elif defined(__MWERKS__) +# if !__option(RTTI) +# define EA_COMPILER_NO_RTTI +# endif +#endif + + + + // EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND + // + // If EA_COMPILER_NO_EXCEPTIONS is defined, then the compiler is + // configured to not recognize C++ exception-handling statements + // such as try/catch/throw. Thus, when EA_COMPILER_NO_EXCEPTIONS is + // defined, code that attempts to use exception handling statements + // will usually cause a compilation error. If is often desirable + // for projects to disable exception handling because exception + // handling causes extra code and/or data generation which might + // not be needed, especially if it is known that exceptions won't + // be happening. When writing code that is to be portable between + // systems of which some enable exception handling while others + // don't, check for EA_COMPILER_NO_EXCEPTIONS being defined. + // +#if defined(EA_COMPILER_GNUC) && defined(_NO_EX) // GCC on some platforms (e.g. PS3) defines _NO_EX when exceptions are disabled. +# define EA_COMPILER_NO_EXCEPTIONS + +#elif (defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_INTEL) || defined(EA_COMPILER_SN)) && !defined(__EXCEPTIONS) // GCC and most EDG-based compilers define __EXCEPTIONS when exception handling is enabled. +# define EA_COMPILER_NO_EXCEPTIONS + +#elif defined(EA_COMPILER_CLANG) && !__has_feature(cxx_exceptions) +# define EA_COMPILER_NO_EXCEPTIONS + +#elif defined(EA_COMPILER_METROWERKS) +# if !__option(exceptions) +# define EA_COMPILER_NO_EXCEPTIONS +# endif + + // Borland and Micrsoft use the _CPUUNWIND define to denote that + // exception stack unwinding code generation is disabled. The result + // is that you can call try/catch/throw and that exceptions will be + // caught handled, but that no automatic object destruction will + // happen between a throw and the resulting catch. We thus don't + // want to define EA_COMPILER_NO_EXCEPTIONS, but perhaps users might + // be interesting in knowing that unwinding is disabled. +#elif (defined(EA_COMPILER_BORLAND) || defined(EA_COMPILER_MSVC)) && !defined(_CPPUNWIND) +# define EA_COMPILER_NO_UNWIND + +#endif // EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND + + + + // EA_COMPILER_NO_STANDARD_CPP_LIBRARY + // + // If defined, then the compiler doesn't provide a Standard C++ library. + // +#if defined(EA_PLATFORM_ANDROID) +# define EA_COMPILER_NO_STANDARD_CPP_LIBRARY +#endif + + + // EA_COMPILER_NO_STATIC_VARIABLE_INIT + // + // If defined, it means that global or static C++ variables will be + // constructed. Not all compiler/platorm combinations support this. + // User code that needs to be portable must avoid having C++ variables + // that construct before main. + // + //#if defined(EA_PLATFORM_MOBILE) + // #define EA_COMPILER_NO_STATIC_VARIABLE_INIT + //#endif + + + + // EA_COMPILER_NO_STATIC_FUNCTION_INIT + // + // If defined, it means that functions marked as startup functions + // (e.g. __attribute__((constructor)) in GCC) are supported. It may + // be that some compiler/platform combinations don't support this. + // + //#if defined(XXX) // So far, all compiler/platforms we use support this. + // #define EA_COMPILER_NO_STATIC_VARIABLE_INIT + //#endif + + + +#endif // INCLUDED_eacompiler_H diff --git a/lib/eastl/include/EABase/config/eacompilertraits.h b/lib/eastl/include/EABase/config/eacompilertraits.h new file mode 100644 index 0000000..d8076af --- /dev/null +++ b/lib/eastl/include/EABase/config/eacompilertraits.h @@ -0,0 +1,1024 @@ +/* +Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*----------------------------------------------------------------------------- + * config/eacompilertraits.h + * + * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. + * Maintained by Paul Pedriana, Maxis + * + *----------------------------------------------------------------------------- + * Currently supported defines include: + * EA_COMPILER_HAS_C99_TYPES + * EA_COMPILER_HAS_CHAR_16_32 + * EA_COMPILER_IS_ANSIC + * EA_COMPILER_IS_C99 + * EA_COMPILER_IS_CPLUSPLUS + * EA_COMPILER_IS_CPLUSPLUS_11_ENABLED + * EA_COMPILER_HAS_MOVE_SEMANTICS + * EA_COMPILER_MANAGED_CPP + * + * EA_ALIGN_OF() + * EA_ALIGN() / EA_PREFIX_ALIGN() / EA_POSTFIX_ALIGN() + * EA_ALIGNED() + * EA_PACKED() + * + * EA_LIKELY() + * EA_UNLIKELY() + * EA_INIT_PRIORITY() + * EA_MAY_ALIAS() + * EA_ASSUME() + * EA_PURE + * EA_WEAK + * + * EA_WCHAR_T_NON_NATIVE + * EA_WCHAR_SIZE = + * + * EA_RESTRICT + * EA_DEPRECATED / EA_PREFIX_DEPRECATED / EA_POSTFIX_DEPRECATED + * EA_FORCE_INLINE / EA_PREFIX_FORCE_INLINE / EA_POSTFIX_FORCE_INLINE + * EA_NO_INLINE / EA_PREFIX_NO_INLINE / EA_POSTFIX_NO_INLINE + * EA_NO_VTABLE / EA_CLASS_NO_VTABLE / EA_STRUCT_NO_VTABLE + * EA_PASCAL + * EA_PASCAL_FUNC() + * EA_SSE = [0 | 1] + * EA_IMPORT + * EA_EXPORT + * EA_PRAGMA_ONCE_SUPPORTED + * EA_OVERRIDE + * EA_SEALED + * EA_ABSTRACT + * + * Todo: + * Find a way to reliably detect wchar_t size at preprocessor time and + * implement it below for EA_WCHAR_SIZE. + * + * Todo: + * Find out how to support EA_PASCAL and EA_PASCAL_FUNC for systems in + * which it hasn't yet been found out for. + *---------------------------------------------------------------------------*/ + + +#ifndef INCLUDED_eacompilertraits_H +#define INCLUDED_eacompilertraits_H + +#ifndef INCLUDED_eaplatform_H +# include "EABase/config/eaplatform.h" +#endif + +#ifndef INCLUDED_eacompiler_H +# include "EABase/config/eacompiler.h" +#endif + + // Metrowerks uses #defines in its core C header files to define + // the kind of information we need below (e.g. C99 compatibility) +#if defined(__MWERKS__) + // Defining the following causes C99 compilers to enable the macros + // associated with the defines. The C99 standard specifies that you + // should define these as such. +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# endif + +# ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS +# endif + +# include +#endif + +#if defined(__SNC__) || defined(EA_PLATFORM_PS3) || defined(__S3E__) +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# endif + +# ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS +# endif + +# include + +# if !defined(EA_COMPILER_HAS_INTTYPES) +# if !defined(__S3E__) +# define EA_COMPILER_HAS_INTTYPES +# endif +# endif +#endif + + // Determine if this compiler is ANSI C compliant and if it is C99 compliant. +#if defined(__STDC__) +# define EA_COMPILER_IS_ANSIC // The compiler claims to be ANSI C + + // Is the compiler a C99 compiler or equivalent? + // From ISO/IEC 9899:1999: + // 6.10.8 Predefined macro names + // __STDC_VERSION__ The integer constant 199901L. (150) + // + // 150) This macro was not specified in ISO/IEC 9899:1990 and was + // specified as 199409L in ISO/IEC 9899/AMD1:1995. The intention + // is that this will remain an integer constant of type long int + // that is increased with each revision of this International Standard. + // +# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +# define EA_COMPILER_IS_C99 +# endif +#endif + + // Some compilers (e.g. GCC) define __USE_ISOC99 if they are not + // strictly C99 compilers (or are simply C++ compilers) but are set + // to use C99 functionality. Metrowerks defines _MSL_C99 as 1 in + // this case, but 0 otherwise. +#if (defined(__USE_ISOC99) || (defined(_MSL_C99) && (_MSL_C99 == 1))) && !defined(EA_COMPILER_IS_C99) +# define EA_COMPILER_IS_C99 +#endif + + // Metrowerks defines C99 types (e.g. intptr_t) instrinsically when in C99 mode (-lang C99 on the command line). +#if (defined(_MSL_C99) && (_MSL_C99 == 1)) +# define EA_COMPILER_HAS_C99_TYPES +#endif + +#if defined(__GNUC__) +# if (((__GNUC__ * 100) + __GNUC_MINOR__) >= 302) // Also, GCC defines _HAS_C9X. +# define EA_COMPILER_HAS_C99_TYPES // The compiler is not necessarily a C99 compiler, but it defines C99 types. +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# endif +# ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS // This tells the GCC compiler that we want it to use its native C99 types. +# endif +# endif +# if (defined(__GXX_EXPERIMENTAL_CXX0X__) && !defined(EA_COMPILER_IS_CPLUSPLUS_11_ENABLED)) +# define EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# define EA_COMPILER_HAS_MOVE_SEMANTICS +# endif + +# define EASTL_GNU_VERSION_NUM (__GNUC__ * 100) + __GNUC_MINOR__ +# ifdef EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# if EASTL_GNU_VERSION_NUM >= 404 +# define EA_COMPILER_HAS_CHAR_16_32 +# define EA_COMPILER_HAS_VARIADIC_TEMPLATES +# endif +# endif +#endif + +#if defined(__clang__) +# if (defined(__GXX_EXPERIMENTAL_CXX0X__) && !defined(EA_COMPILER_IS_CPLUSPLUS_11_ENABLED)) +# define EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# define EA_COMPILER_HAS_MOVE_SEMANTICS +# endif + +# define EASTL_CLANG_VERSION_NUM (__clang_major__ * 10) + __clang_minor__ +# if EASTL_CLANG_VERSION_NUM >= 29 +# define EA_COMPILER_HAS_C99_TYPES +# endif +# ifdef EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# if EASTL_CLANG_VERSION_NUM >= 29 +# define EA_COMPILER_HAS_CHAR_16_32 +# define EA_COMPILER_HAS_VARIADIC_TEMPLATES +# endif +# endif + +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# endif +# ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS // This tells the GCC compiler that we want it to use its native C99 types. +# endif +#endif + +#if defined(_MSC_VER) +# if (_MSC_VER >= 1600) +# define EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# define EA_COMPILER_HAS_MOVE_SEMANTICS +# endif +#endif + +#ifdef __cplusplus +# define EA_COMPILER_IS_CPLUSPLUS +# if (__cplusplus > 199711L) +# define EA_COMPILER_IS_CPLUSPLUS_11_ENABLED +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_COMPILER_MANAGED_CPP + // Defined if this is being compiled with Managed C++ extensions +#ifdef EA_COMPILER_MSVC +# if EA_COMPILER_VERSION >= 1300 +# ifdef _MANAGED +# define EA_COMPILER_MANAGED_CPP +# endif +# endif +#endif + + + // ------------------------------------------------------------------------ + // alignment expressions + // + // Here we define + // EA_ALIGN_OF(type) // Returns size_t. + // EA_ALIGN(n) // Used as a prefix. n is byte alignment, with being a power of two. Most of the time you can use this and avoid using EA_PREFIX_ALIGN/EA_POSTFIX_ALIGN. + // EA_PREFIX_ALIGN(n) // n is byte alignment, with being a power of two. You should need this only for unusual compilers. + // EA_POSTFIX_ALIGN(n) // Valid values for n are 1, 2, 4, 8, etc. You should need this only for unusual compilers. + // EA_ALIGNED(t, v, n) // Type, variable, alignment. Used to align an instance. You should need this only for unusual compilers. + // EA_PACKED // Specifies that the given structure be packed (and not have its members aligned). + // + // Example usage: + // size_t x = EA_ALIGN_OF(int); Non-aligned equivalents. Meaning + // EA_PREFIX_ALIGN(8) int x = 5; int x = 5; Align x on 8 for compilers that require prefix attributes. Can just use EA_ALIGN instead. + // EA_ALIGN(8) int x; int x; Align x on 8 for compilers that allow prefix attributes. + // int x EA_POSTFIX_ALIGN(8); int x; Align x on 8 for compilers that require postfix attributes. + // int x EA_POSTFIX_ALIGN(8) = 5; int x = 5; Align x on 8 for compilers that require postfix attributes. + // int x EA_POSTFIX_ALIGN(8)(5); int x(5); Align x on 8 for compilers that require postfix attributes. + // struct EA_PREFIX_ALIGN(8) X { int x; } EA_POSTFIX_ALIGN(8); struct X { int x; }; Define X as a struct which is aligned on 8 when used. + // EA_ALIGNED(int, x, 8) = 5; int x = 5; Align x on 8. + // EA_ALIGNED(int, x, 16)(5); int x(5); Align x on 16. + // EA_ALIGNED(int, x[3], 16); int x[3]; Align x array on 16. + // EA_ALIGNED(int, x[3], 16) = { 1, 2, 3 }; int x[3] = { 1, 2, 3 }; Align x array on 16. + // int x[3] EA_PACKED; int x[3]; Pack the 3 ints of the x array. GCC doesn't seem to support packing of int arrays. + // struct EA_ALIGN(32) X { int x; int y; }; struct X { int x; }; Define A as a struct which is aligned on 32 when used. + // EA_ALIGN(32) struct X { int x; int y; } Z; struct X { int x; } Z; Define A as a struct, and align the instance Z on 32. + // struct X { int x EA_PACKED; int y EA_PACKED; }; struct X { int x; int y; }; Pack the x and y members of struct X. + // struct X { int x; int y; } EA_PACKED; struct X { int x; int y; }; Pack the members of struct X. + // typedef EA_ALIGNED(int, int16, 16); int16 n16; typedef int int16; int16 n16; Define int16 as an int which is aligned on 16. + // typedef EA_ALIGNED(X, X16, 16); X16 x16; typedef X X16; X16 x16; Define X16 as an X which is aligned on 16. + + // SNC (EDG) intends to be compatible with GCC but has a bug whereby it + // fails to support calling a constructor in an aligned declaration when + // using postfix alignment attributes. Prefix works for alignment, but does not align + // the size like postfix does. Prefix also fails on templates. So gcc style post fix + // is still used, but the user will need to use EA_POSTFIX_ALIGN before the constructor parameters. + // this note by Paul and Frank +#if defined(EA_COMPILER_SN) && defined(__GNUC__) // If using the SN compiler in GCC compatibility mode... +# define EA_ALIGN_OF(type) ((size_t)__alignof__(type)) +# define EA_ALIGN(n) __attribute__((aligned(n))) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) __attribute__((aligned(n))) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable __attribute__((aligned(n))) +# define EA_PACKED __attribute__((packed)) + + // GCC 2.x doesn't support prefix attributes. +#elif defined(__GNUC__) && (__GNUC__ < 3) +# define EA_ALIGN_OF(type) ((size_t)__alignof__(type)) +# define EA_ALIGN(n) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) __attribute__((aligned(n))) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable __attribute__((aligned(n))) +# define EA_PACKED __attribute__((packed)) + + // GCC 3.x+ and IBM C support prefix attributes. +#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__xlC__) +# define EA_ALIGN_OF(type) ((size_t)__alignof__(type)) +# define EA_ALIGN(n) __attribute__((aligned(n))) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) __attribute__((aligned(n))) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable __attribute__((aligned(n))) +# define EA_PACKED __attribute__((packed)) + +#elif defined(EA_COMPILER_CLANG) + // Checks for clang-supported attributes +# if __has_attribute(aligned) +# define CLANG_ALIGNED(n) __attribute__((aligned(n))) +# else +# define CLANG_ALIGNED(n) +# endif + +# if __has_attribute(packed) +# define CLANG_PACKED __attribute__((packed)) +# else +# define CLANG_PACKED +# endif + + // Now we define the alignment stuff +# define EA_ALIGN_OF(type) ((size_t)__alignof__(type)) +# define EA_ALIGN(n) CLANG_ALIGNED(n) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) CLANG_ALIGNED(n) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable __attribute__((aligned(n))) +# define EA_PACKED CLANG_PACKED + + // Make sure we get no macro naming conflicts +# undef CLANG_ALIGNED +# undef CLANG_PACKED + + // Metrowerks supports prefix attributes. + // Metrowerks does not support packed alignment attributes. +#elif defined(EA_COMPILER_METROWERKS) +# define EA_ALIGN_OF(type) ((size_t)__alignof__(type)) +# define EA_ALIGN(n) __attribute__((aligned(n))) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) __attribute__((aligned(n))) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable __attribute__((aligned(n))) +# define EA_PACKED + + // Microsoft supports prefix alignment via __declspec, but the alignment value must be a literal number, not just a constant expression. + // Contrary to VC7.x and earlier documentation, __declspec(align) works on stack variables. VC8+ (VS2005+) documents correctly. + // Microsoft does not support packed alignment attributes; you must use #pragma pack. +#elif defined(EA_COMPILER_INTEL) || defined(EA_PLATFORM_XBOX) || (defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1300)) +# define EA_ALIGN_OF(type) ((size_t)__alignof(type)) +# define EA_ALIGN(n) __declspec(align(n)) +# define EA_PREFIX_ALIGN(n) __declspec(align(n)) +# define EA_POSTFIX_ALIGN(n) +# define EA_ALIGNED(variable_type, variable, n) __declspec(align(n)) variable_type variable +# define EA_PACKED + + // Arm brand compiler +#elif defined(__ARMCC_VERSION) +# define EA_ALIGN_OF(type) ((size_t)__ALIGNOF__(type)) +# define EA_ALIGN(n) __align(n) +# define EA_PREFIX_ALIGN(n) __align(n) +# define EA_POSTFIX_ALIGN(n) +# define EA_ALIGNED(variable_type, variable, n) __align(n) variable_type variable +# define EA_PACKED __packed + +#else // Unusual compilers + // There is nothing we can do about some of these. This is not as bad a problem as it seems. + // If the given platform/compiler doesn't support alignment specifications, then it's somewhat + // likely that alignment doesn't matter for that platform. Otherwise they would have defined + // functionality to manipulate alignment. +# define EA_ALIGN(n) +# define EA_PREFIX_ALIGN(n) +# define EA_POSTFIX_ALIGN(n) +# define EA_ALIGNED(variable_type, variable, n) variable_type variable +# define EA_PACKED + +# ifdef __cplusplus + template struct EAAlignOf1 { enum { s = sizeof (T), value = s ^ (s & (s - 1)) }; }; + template struct EAAlignOf2; + template struct helper { template struct Val { enum { value = size_diff }; }; }; + template <> struct helper<0> { template struct Val { enum { value = EAAlignOf2::value }; }; }; + template struct EAAlignOf2 { struct Big { T x; char c; }; + enum { diff = sizeof (Big) - sizeof (T), value = helper::template Val::value }; }; + template struct EAAlignof3 { enum { x = EAAlignOf2::value, y = EAAlignOf1::value, value = x < y ? x : y }; }; +# define EA_ALIGN_OF(type) ((size_t)EAAlignof3::value) + +# else + // C implementation of EA_ALIGN_OF + // This implementation works for most cases, but doesn't directly work + // for types such as function pointer declarations. To work with those + // types you need to typedef the type and then use the typedef in EA_ALIGN_OF. +# define EA_ALIGN_OF(type) ((size_t)offsetof(struct { char c; type m; }, m)) +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_LIKELY / EA_UNLIKELY + // + // Defined as a macro which gives a hint to the compiler for branch + // prediction. GCC gives you the ability to manually give a hint to + // the compiler about the result of a comparison, though it's often + // best to compile shipping code with profiling feedback under both + // GCC (-fprofile-arcs) and VC++ (/LTCG:PGO, etc.). However, there + // are times when you feel very sure that a boolean expression will + // usually evaluate to either true or false and can help the compiler + // by using an explicity directive... + // + // Example usage: + // if(EA_LIKELY(a == 0)) // Tell the compiler that a will usually equal 0. + // { ... } + // + // Example usage: + // if(EA_UNLIKELY(a == 0)) // Tell the compiler that a will usually not equal 0. + // { ... } + // +#ifndef EA_LIKELY +# if (defined(__GNUC__) && (__GNUC__ >= 3)) || \ + (defined(__clang__) && __has_builtin(__builtin_expect)) || \ + defined(__MWERKS__) // Metrowerks supports __builtin_expect, but with some platforms (e.g. Wii) it appears to ignore it. + +# if defined(__cplusplus) +# define EA_LIKELY(x) __builtin_expect(!!(x), true) +# define EA_UNLIKELY(x) __builtin_expect(!!(x), false) +# else +# define EA_LIKELY(x) __builtin_expect(!!(x), 1) +# define EA_UNLIKELY(x) __builtin_expect(!!(x), 0) +# endif +# else +# define EA_LIKELY(x) (x) +# define EA_UNLIKELY(x) (x) +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_INIT_PRIORITY + // + // This is simply a wrapper for the GCC init_priority attribute that allows + // multiplatform code to be easier to read. This attribute doesn't apply + // to VC++ because VC++ uses file-level pragmas to control init ordering. + // + // Example usage: + // SomeClass gSomeClass EA_INIT_PRIORITY(2000); + // +#if !defined(EA_INIT_PRIORITY) +# if defined(__GNUC__) +# define EA_INIT_PRIORITY(x) __attribute__ ((init_priority (x))) +# else +# define EA_INIT_PRIORITY(x) +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_MAY_ALIAS + // + // Defined as a macro that wraps the GCC may_alias attribute. This attribute + // has no significance for VC++ because VC++ doesn't support the concept of + // strict aliasing. Users should avoid writing code that breaks strict + // aliasing rules; EA_MAY_ALIAS is for cases with no alternative. + // + // Example usage: + // void* EA_MAY_ALIAS gPtr = NULL; + // + // Example usage: + // typedef void* EA_MAY_ALIAS pvoid_may_alias; + // pvoid_may_alias gPtr = NULL; + // +#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 303) +# define EA_MAY_ALIAS __attribute__((__may_alias__)) +#elif defined(EA_COMPILER_CLANG) && __has_attribute(__may_alias__) +# define EA_MAY_ALIAS __attribute__((__may_alias__)) +#else +# define EA_MAY_ALIAS +#endif + + + // ------------------------------------------------------------------------ + // EA_ASSUME + // + // This acts the same as the VC++ __assume directive and is implemented + // simply as a wrapper around it to allow portable usage of it and to take + // advantage of it if and when it appears in other compilers. + // + // Example usage: + // void Function(int a) { + // switch(a) { + // case 1: + // DoSomething(1); + // break; + // case 2: + // DoSomething(-1); + // break; + // default: + // EA_ASSUME(0); // This tells the optimizer that the default cannot be reached. + // } + // } + // +#ifndef EA_ASSUME +# if defined(_MSC_VER) && (_MSC_VER >= 1300) // If VC7.0 and later (including XBox, and XBox 360)... +# define EA_ASSUME(x) __assume(x) +# else +# define EA_ASSUME(x) +# endif +#endif + + + + // ------------------------------------------------------------------------ + // EA_PURE + // + // This acts the same as the GCC __attribute__ ((pure)) directive and is + // implemented simply as a wrapper around it to allow portable usage of + // it and to take advantage of it if and when it appears in other compilers. + // + // A "pure" function is one that has no effects except its return value and + // its return value is a function of only the function's parameters or + // non-volatile global variables. Any parameter or global variable access + // must be read-only. Loop optimization and subexpression elimination can be + // applied to such functions. A common example is strlen(): Given identical + // inputs, the function's return value (its only effect) is invariant across + // multiple invocations and thus can be pulled out of a loop and called but once. + // + // Example usage: + // EA_PURE void Function(); + // +#ifndef EA_PURE +# if defined(EA_COMPILER_GNUC) +# define EA_PURE __attribute__((pure)) +# elif defined(EA_COMPILER_CLANG) && __has_attribute(pure) +# define EA_PURE __attribute__((pure)) +# elif defined(__ARMCC_VERSION) // Arm brand compiler for ARM CPU +# define EA_PURE __pure +# else +# define EA_PURE +# endif +#endif + + + + // ------------------------------------------------------------------------ + // EA_WEAK + // EA_WEAK_SUPPORTED -- defined as 0 or 1. + // + // GCC + // The weak attribute causes the declaration to be emitted as a weak + // symbol rather than a global. This is primarily useful in defining + // library functions which can be overridden in user code, though it + // can also be used with non-function declarations. + // + // VC++ + // At link time, if multiple definitions of a COMDAT are seen, the linker + // picks one and discards the rest. If the linker option /OPT:REF + // is selected, then COMDAT elimination will occur to remove all the + // unreferenced data items in the linker output. + // + // Example usage: + // EA_WEAK void Function(); + // +#ifndef EA_WEAK +# if defined(_MSC_VER) && (_MSC_VER >= 1300) // If VC7.0 and later (including XBox)... +# define EA_WEAK __declspec(selectany) +# define EA_WEAK_SUPPORTED 1 +# elif defined(_MSC_VER) || (defined(__GNUC__) && defined(__CYGWIN__)) +# define EA_WEAK +# define EA_WEAK_SUPPORTED 0 +# elif defined(__ARMCC_VERSION) // Arm brand compiler for ARM CPU +# define EA_WEAK __weak +# define EA_WEAK_SUPPORTED 1 +# else // GCC and IBM compilers, others. +# define EA_WEAK __attribute__((weak)) +# define EA_WEAK_SUPPORTED 1 +# endif +#endif + + + + // ------------------------------------------------------------------------ + // wchar_t + // Here we define: + // EA_WCHAR_T_NON_NATIVE + // EA_WCHAR_SIZE = + // +#ifndef EA_WCHAR_T_NON_NATIVE + // Compilers that always implement wchar_t as native include: + // COMEAU, new SN, and other EDG-based compilers. + // GCC + // Borland + // SunPro + // IBM Visual Age +# if defined(EA_COMPILER_INTEL) +# if (EA_COMPILER_VERSION < 700) +# define EA_WCHAR_T_NON_NATIVE 1 +# else +# if (!defined(_WCHAR_T_DEFINED) && !defined(_WCHAR_T)) +# define EA_WCHAR_T_NON_NATIVE 1 +# endif +# endif +# elif defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_BORLAND) +# ifndef _NATIVE_WCHAR_T_DEFINED +# define EA_WCHAR_T_NON_NATIVE 1 +# endif +# elif defined(EA_COMPILER_METROWERKS) +# if !__option(wchar_type) +# define EA_WCHAR_T_NON_NATIVE 1 +# endif +# elif defined(__SNC__) && !defined(__cplusplus) // If compiling C under SNC... +# define EA_WCHAR_T_NON_NATIVE 1 +# endif +#endif + +#ifndef EA_WCHAR_SIZE // If the user hasn't specified that it is a given size... +# if defined(__WCHAR_MAX__) // GCC defines this for most platforms. +# if (__WCHAR_MAX__ == 2147483647) || (__WCHAR_MAX__ == 4294967295) +# define EA_WCHAR_SIZE 4 +# elif (__WCHAR_MAX__ == 32767) || (__WCHAR_MAX__ == 65535) +# define EA_WCHAR_SIZE 2 +# elif (__WCHAR_MAX__ == 127) || (__WCHAR_MAX__ == 255) +# define EA_WCHAR_SIZE 1 +# else +# define EA_WCHAR_SIZE 4 +# endif +# elif defined(WCHAR_MAX) // The SN and Arm compilers define this. +# if (WCHAR_MAX == 2147483647) || (WCHAR_MAX == 4294967295) +# define EA_WCHAR_SIZE 4 +# elif (WCHAR_MAX == 32767) || (WCHAR_MAX == 65535) +# define EA_WCHAR_SIZE 2 +# elif (WCHAR_MAX == 127) || (WCHAR_MAX == 255) +# define EA_WCHAR_SIZE 1 +# else +# define EA_WCHAR_SIZE 4 +# endif +# elif defined(_WCMAX) // The SN and Arm compilers define this. +# if (_WCMAX == 2147483647) || (_WCMAX == 4294967295) +# define EA_WCHAR_SIZE 4 +# elif (_WCMAX == 32767) || (_WCMAX == 65535) +# define EA_WCHAR_SIZE 2 +# elif (_WCMAX == 127) || (_WCMAX == 255) +# define EA_WCHAR_SIZE 1 +# else +# define EA_WCHAR_SIZE 4 +# endif +# elif defined(EA_PLATFORM_UNIX) || defined(EA_PLATFORM_PS3) || defined(EA_PLATFORM_PS3_SPU) + // It is standard on Unix to have wchar_t be int32_t or uint32_t. + // All versions of GNUC default to a 32 bit wchar_t, but has been used + // with the -fshort-wchar GCC command line option to force it to 16 bit. + // If you know that the compiler is set to use a wchar_t of other than + // the default, you need to manually define EA_WCHAR_SIZE for the build. +# define EA_WCHAR_SIZE 4 +# else + // It is standard on Windows to have wchar_t be uint16_t. + // Metrowerks and the new EDG-based SN compilers define wchar_t + // as uint16_t. Given that there is currently no known way to tell at preprocessor + // time what the size of wchar_t is, we declare it to be 2. + // If you have EA_WCHAR_SIZE != sizeof(wchar_t), then your + // code might not be broken, but it also won't work with wchar libraries + // and data from other parts of EA. Under GCC, you can force wchar_t + // to two bytes with the -fshort-wchar compiler argument. +# define EA_WCHAR_SIZE 2 +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_RESTRICT + // + // The C99 standard defines a new keyword, restrict, which allows for the + // improvement of code generation regarding memory usage. Compilers can + // generate significantly faster code when you are able to use restrict. + // + // Example usage: + // void DoSomething(char* EA_RESTRICT p1, char* EA_RESTRICT p2); + // +#ifndef EA_RESTRICT +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // If VC8 (VS2005) or later... +# define EA_RESTRICT __restrict +# elif defined(EA_COMPILER_GNUC) +# define EA_RESTRICT __restrict // GCC defines 'restrict' (as opposed to __restrict) in C99 mode only. +# elif defined(EA_COMPILER_CLANG) +# define EA_RESTRICT __restrict +# elif defined(__ARMCC_VERSION) +# define EA_RESTRICT __restrict +# elif defined(__MWERKS__) +# if __option(c99) +# define EA_RESTRICT restrict +# else +# define EA_RESTRICT +# endif +# elif defined(EA_COMPILER_IS_C99) +# define EA_RESTRICT restrict +# else + // If the compiler didn't support restricted pointers, defining EA_RESTRICT + // away would result in compiling and running fine but you just wouldn't + // the same level of optimization. On the other hand, all the major compilers + // support restricted pointers. +# define EA_RESTRICT +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_DEPRECATED // Used as a prefix. + // EA_PREFIX_DEPRECATED // You should need this only for unusual compilers. + // EA_POSTFIX_DEPRECATED // You should need this only for unusual compilers. + // + // Example usage: + // EA_DEPRECATED void Function(); + // + // or for maximum portability: + // EA_PREFIX_DEPRECATED void Function() EA_POSTFIX_DEPRECATED; + // +#ifndef EA_DEPRECATED +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION > 1300) // If VC7 (VS2003) or later... +# define EA_DEPRECATED __declspec(deprecated) +# elif defined(EA_COMPILER_MSVC) +# define EA_DEPRECATED +# else +# define EA_DEPRECATED __attribute__((deprecated)) +# endif +#endif + +#ifndef EA_PREFIX_DEPRECATED +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION > 1300) // If VC7 (VS2003) or later... +# define EA_PREFIX_DEPRECATED __declspec(deprecated) +# define EA_POSTFIX_DEPRECATED +# elif defined(EA_COMPILER_MSVC) +# define EA_PREFIX_DEPRECATED +# define EA_POSTFIX_DEPRECATED +# else +# define EA_PREFIX_DEPRECATED +# define EA_POSTFIX_DEPRECATED __attribute__((deprecated)) +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_FORCE_INLINE // Used as a prefix. + // EA_PREFIX_FORCE_INLINE // You should need this only for unusual compilers. + // EA_POSTFIX_FORCE_INLINE // You should need this only for unusual compilers. + // + // Example usage: + // EA_FORCE_INLINE void Foo(); // Implementation elsewhere. + // EA_PREFIX_FORCE_INLINE void Foo() EA_POSTFIX_FORCE_INLINE; // Implementation elsewhere. + // + // Note that when the prefix version of this function is used, it replaces + // the regular C++ 'inline' statement. Thus you should not use both the + // C++ inline statement and this macro with the same function declaration. + // + // To force inline usage under GCC 3.1+, you use this: + // inline void Foo() __attribute__((always_inline)); + // or + // inline __attribute__((always_inline)) void Foo(); + // + // The CodeWarrior compiler doesn't have the concept of forcing inlining per function. + // +#ifndef EA_FORCE_INLINE +# if defined(EA_COMPILER_MSVC) +# define EA_FORCE_INLINE __forceinline +# elif defined(EA_COMPILER_GNUC) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 301) +# if defined(__cplusplus) +# define EA_FORCE_INLINE inline __attribute__((always_inline)) +# else +# define EA_FORCE_INLINE __inline__ __attribute__((always_inline)) +# endif +# elif defined(EA_COMPILER_CLANG) && __has_attribute(always_inline) +# if defined(__cplusplus) +# define EA_FORCE_INLINE inline __attribute__((always_inline)) +# else +# define EA_FORCE_INLINE __inline__ __attribute__((always_inline)) +# endif +# else +# if defined(__cplusplus) +# define EA_FORCE_INLINE inline +# else +# define EA_FORCE_INLINE __inline +# endif +# endif +#endif + +#if defined(EA_COMPILER_SN) && defined(EA_PLATFORM_PS3) // SN's implementation of always_inline is broken and sometimes fails to link the function. +# define EA_PREFIX_FORCE_INLINE inline +# define EA_POSTFIX_FORCE_INLINE +#elif defined(EA_COMPILER_GNUC) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 301) +# define EA_PREFIX_FORCE_INLINE inline +# define EA_POSTFIX_FORCE_INLINE __attribute__((always_inline)) +#else +# define EA_PREFIX_FORCE_INLINE inline +# define EA_POSTFIX_FORCE_INLINE +#endif + + + // ------------------------------------------------------------------------ + // EA_NO_INLINE // Used as a prefix. + // EA_PREFIX_NO_INLINE // You should need this only for unusual compilers. + // EA_POSTFIX_NO_INLINE // You should need this only for unusual compilers. + // + // Example usage: + // EA_NO_INLINE void Foo(); // Implementation elsewhere. + // EA_PREFIX_NO_INLINE void Foo() EA_POSTFIX_NO_INLINE; // Implementation elsewhere. + // + // That this declaration is incompatbile with C++ 'inline' and any + // variant of EA_FORCE_INLINE. + // + // To disable inline usage under VC++ priof to VS2005, you need to use this: + // #pragma inline_depth(0) // Disable inlining. + // void Foo() { ... } + // #pragma inline_depth() // Restore to default. + // + // Since there is no easy way to disable inlining on a function-by-function + // basis in VC++ prior to VS2005, the best strategy is to write platform-specific + // #ifdefs in the code or to disable inlining for a given module and enable + // functions individually with EA_FORCE_INLINE. + // +#ifndef EA_NO_INLINE +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // If VC8 (VS2005) or later... +# define EA_NO_INLINE __declspec(noinline) +# elif defined(EA_COMPILER_MSVC) +# define EA_NO_INLINE +# else +# define EA_NO_INLINE __attribute__((noinline)) +# endif +#endif + +#if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // If VC8 (VS2005) or later... +# define EA_PREFIX_NO_INLINE __declspec(noinline) +# define EA_POSTFIX_NO_INLINE +#elif defined(EA_COMPILER_MSVC) +# define EA_PREFIX_NO_INLINE +# define EA_POSTFIX_NO_INLINE +#else +# define EA_PREFIX_NO_INLINE +# define EA_POSTFIX_NO_INLINE __attribute__((noinline)) +#endif + + + // ------------------------------------------------------------------------ + // EA_NO_VTABLE + // + // Example usage: + // class EA_NO_VTABLE X { + // virtual void InterfaceFunction(); + // }; + // + // EA_CLASS_NO_VTABLE(X) { + // virtual void InterfaceFunction(); + // }; + // +#ifdef EA_COMPILER_MSVC +# define EA_NO_VTABLE __declspec(novtable) +# define EA_CLASS_NO_VTABLE(x) class __declspec(novtable) x +# define EA_STRUCT_NO_VTABLE(x) struct __declspec(novtable) x +#else +# define EA_NO_VTABLE +# define EA_CLASS_NO_VTABLE(x) class x +# define EA_STRUCT_NO_VTABLE(x) struct x +#endif + + + // ------------------------------------------------------------------------ + // EA_PASCAL + // + // Also known on PC platforms as stdcall. + // This convention causes the compiler to assume that the called function + // will pop off the stack space used to pass arguments, unless it takes a + // variable number of arguments. + // + // Example usage: + // this: + // void DoNothing(int x); + // void DoNothing(int x){} + // would be written as this: + // void EA_PASCAL_FUNC(DoNothing(int x)); + // void EA_PASCAL_FUNC(DoNothing(int x)){} + // +#ifndef EA_PASCAL +# if defined(EA_COMPILER_MSVC) +# define EA_PASCAL __stdcall +# elif defined(EA_COMPILER_GNUC) && defined(EA_PROCESSOR_X86) +# define EA_PASCAL __attribute__((stdcall)) +# elif defined(EA_COMPILER_METROWERKS) && defined(EA_PLATFORM_WINDOWS) + // You need to make sure you have the Metrowerks "ANSI keywords only' + // compilation option disabled for the pascal keyword to work. +# define EA_PASCAL pascal +# else + // Some compilers simply don't support pascal calling convention. + // As a result, there isn't an issue here, since the specification of + // pascal calling convention is for the purpose of disambiguating the + // calling convention that is applied. +# define EA_PASCAL +# endif +#endif + +#ifndef EA_PASCAL_FUNC +# if defined(EA_COMPILER_MSVC) +# define EA_PASCAL_FUNC(funcname_and_paramlist) __stdcall funcname_and_paramlist +# elif defined(EA_COMPILER_GNUC) && defined(EA_PROCESSOR_X86) +# define EA_PASCAL_FUNC(funcname_and_paramlist) __attribute__((stdcall)) funcname_and_paramlist +# elif defined(EA_COMPILER_METROWERKS) && defined(EA_PLATFORM_WINDOWS) +# define EA_PASCAL_FUNC(funcname_and_paramlist) pascal funcname_and_paramlist +# else +# define EA_PASCAL_FUNC(funcname_and_paramlist) funcname_and_paramlist +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_SSE + // Visual C Processor Packs define _MSC_FULL_VER and are needed for SSE + // Intel C also has SSE support. + // EA_SSE is used to select FPU or SSE versions in hw_select.inl +#ifndef EA_SSE +# if defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_CLANG) +# if defined(__SSE2__) +# define EA_SSE 2 +# elif defined(__SSE__) && __SSE__ +# define EA_SSE 1 +# else +# define EA_SSE 0 +# endif +# elif defined(EA_PROCESSOR_X86) && defined(_MSC_FULL_VER) && !defined(__NOSSE__) && defined(_M_IX86_FP) +# define EA_SSE _M_IX86_FP +# elif defined(EA_PROCESSOR_X86) && defined(EA_COMPILER_INTEL) && !defined(__NOSSE__) +# define EA_SSE 1 +# else +# define EA_SSE 0 +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_IMPORT + // import declaration specification + // specifies that the declared symbol is imported from another dynamic library. +#ifndef EA_IMPORT +# if defined(EA_COMPILER_MSVC) +# define EA_IMPORT __declspec(dllimport) +# else +# define EA_IMPORT +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_EXPORT + // export declaration specification + // specifies that the declared symbol is exported from the current dynamic library. + // this is not the same as the C++ export keyword. +#ifndef EA_EXPORT +# if defined(EA_COMPILER_MSVC) +# define EA_EXPORT __declspec(dllexport) +# else +# define EA_EXPORT +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_PRAGMA_ONCE_SUPPORTED + // + // This is a wrapper for the #pragma once preprocessor directive. + // It allows for some compilers (in particular VC++) to implement signifcantly + // faster include file preprocessing. #pragma once can be used to replace + // header include guards or to augment them. However, #pragma once isn't + // necessarily supported by all compilers and isn't guaranteed to be so in + // the future, so using #pragma once to replace traditional include guards + // is not strictly portable. Note that a direct #define for #pragma once is + // impossible with VC++, due to limitations, but can be done with other + // compilers/preprocessors via _Pragma("once"). + // + // Example usage (which includes traditional header guards for portability): + // #ifndef SOMEPACKAGE_SOMEHEADER_H + // #define SOMEPACKAGE_SOMEHEADER_H + // + // #if defined(EA_PRAGMA_ONCE_SUPPORTED) + // #pragma once + // #endif + // + // + // + // #endif + // +#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__GNUC__) || defined(__SNC__) || defined(__ICC) || defined(__ICL) || defined(__clang__) +# define EA_PRAGMA_ONCE_SUPPORTED 1 +#endif + + + // ------------------------------------------------------------------------ + // EA_OVERRIDE + // + // See http://msdn.microsoft.com/en-us/library/41w3sh1c.aspx for more information. + // +#ifndef EA_OVERRIDE +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // VS2005 (VC8) and later +# define EA_OVERRIDE override +# else +# define EA_OVERRIDE +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_SEALED + // + // See http://msdn.microsoft.com/en-us/library/49k3w2fx%28VS.71%29.aspx for more information. + // +#ifndef EA_SEALED +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // VS2005 (VC8) and later +# define EA_SEALED sealed +# else +# define EA_SEALED +# endif +#endif + + + // ------------------------------------------------------------------------ + // EA_ABSTRACT + // + // See http://msdn.microsoft.com/en-us/library/49k3w2fx%28VS.71%29.aspx for more information. + // +#ifndef EA_ABSTRACT +# if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1400) // VS2005 (VC8) and later +# define EA_ABSTRACT abstract +# else +# define EA_ABSTRACT +# endif +#endif + + +#endif // Header include guard diff --git a/lib/eastl/include/EABase/config/eaplatform.h b/lib/eastl/include/EABase/config/eaplatform.h new file mode 100644 index 0000000..5b0554b --- /dev/null +++ b/lib/eastl/include/EABase/config/eaplatform.h @@ -0,0 +1,559 @@ +/* +Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*----------------------------------------------------------------------------- + * config/eaplatform.h + * + * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. + * Maintained by Paul Pedriana, Maxis + * + *----------------------------------------------------------------------------- + * Currently supported platform indentification defines include: + * EA_PLATFORM_PS3 + * EA_PLATFORM_PS3_PPU + * EA_PLATFORM_PS3_SPU + * EA_PLATFORM_XENON (a.k.a. XBox2) + * EA_PLATFORM_MAC + * EA_PLATFORM_OSX + * EA_PLATFORM_LINUX + * EA_PLATFORM_WINDOWS + * EA_PLATFORM_WIN32 + * EA_PLATFORM_WIN64 + * EA_PLATFORM_HPUX + * EA_PLATFORM_SUN + * EA_PLATFORM_LRB (Larrabee) + * EA_PLATFORM_UNIX (pseudo-platform; may be defined along with another platform like EA_PLATFORM_LINUX) + * EA_PLATFORM_CYGWIN (pseudo-platform; may be defined along with another platform like EA_PLATFORM_LINUX) + * EA_PLATFORM_MINGW (pseudo-platform; may be defined along with another platform like EA_PLATFORM_WINDOWS) + * EA_PLATFORM_MICROSOFT (pseudo-platform; may be defined along with another platform like EA_PLATFORM_WINDOWS) + * + * Other definitions emanated from this file inclue: + * EA_PLATFORM_NAME = + * EA_PLATFORM_DESCRIPTION = + * EA_PROCESSOR_XXX + * EA_SYSTEM_LITTLE_ENDIAN | EA_SYSTEM_BIG_ENDIAN + * EA_ASM_STYLE_ATT | EA_ASM_STYLE_INTEL | EA_ASM_STYLE_MOTOROLA + * EA_PLATFORM_PTR_SIZE = + * EA_PLATFORM_WORD_SIZE = + * + *---------------------------------------------------------------------------*/ + + +#ifndef INCLUDED_eaplatform_H +#define INCLUDED_eaplatform_H + + +// Cygwin +// This is a pseudo-platform which will be defined along with EA_PLATFORM_LINUX when +// using the Cygwin build environment. +#if defined(__CYGWIN__) + #define EA_PLATFORM_CYGWIN + #define EA_PLATFORM_DESKTOP +#endif + +// MinGW +// This is a pseudo-platform which will be defined along with EA_PLATFORM_WINDOWS when +// using the MinGW Windows build environment. +#if defined(__MINGW32__) || defined(__MINGW64__) + #define EA_PLATFORM_MINGW + #define EA_PLATFORM_DESKTOP +#endif + +// PlayStation 3 PPU (Primary Processing Unit) +#if defined(EA_PLATFORM_PS3_PPU) || defined(EA_PLATFORM_PS3) || defined(__PU__) || defined(__PPU__) + #undef EA_PLATFORM_PS3_PPU + #define EA_PLATFORM_PS3_PPU 1 + #undef EA_PLATFORM_PS3 + #define EA_PLATFORM_PS3 1 + #define EA_PLATFORM_NAME "PS3" + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_64 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "PS3 on PowerPC" + #define EA_PLATFORM_CONSOLE + +// PlayStation 3 SPU (Synergistic Processing Unit) +#elif defined(EA_PLATFORM_PS3_SPU) || defined(__SPU__) + #undef EA_PLATFORM_PS3_SPU + #define EA_PLATFORM_PS3_SPU 1 + #define EA_PLATFORM_NAME "PS3 SPU" + #define EA_PROCESSOR_SPU + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "PS3 SPU on SPU" + #define EA_PLATFORM_CONSOLE + +// XBox +// _XBOX is defined by the VC++ project, not the compiler. There is no way +// to tell if the compiler is compiling for XBox unless _XBOX is #defined +// in the project files or otherwise. _M_IX86 is the VC++ way of detecting +// an x86 target, which would mean XBox and not Xenon (a.k.a. XBox2). +#elif defined(EA_PLATFORM_XBOX) || (defined(_XBOX) && defined(_M_IX86)) + #undef EA_PLATFORM_XBOX + #define EA_PLATFORM_XBOX 1 + #define EA_PLATFORM_NAME "XBox" + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "XBox on X86" + #if defined(_MSC_VER) || defined(__ICL) + #define EA_ASM_STYLE_INTEL + #endif + #define EA_PLATFORM_CONSOLE + +// Xenon (XBox 360) +// The Xenon compiler doesn't define anything in particular to indicate that the +// target is the Xenon platform. The Xenon SDK, however, expects that XBOX and +// _XBOX are #defined, so the project build file must make sure these are defined. +// Since the Xenon compiler in fact defines _M_PPC, we can use this information +// to infer that Xenon is the target if neither _XENON nor _XBOX2 are specifically +// defined by the project build file. +#elif defined(EA_PLATFORM_XENON) || defined(_XENON) || defined(_XBOX2) || ((defined(_XBOX) || defined(XBOX)) && defined(_M_PPC)) + #undef EA_PLATFORM_XENON + #define EA_PLATFORM_XENON 1 + #define EA_PLATFORM_NAME "Xenon" + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_64 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Xenon on PowerPC" + #if defined(_MSC_VER) || defined(__ICL) + #define EA_ASM_STYLE_INTEL + #endif + #define EA_PLATFORM_CONSOLE + #define EA_PLATFORM_MICROSOFT 1 + +// Larrabee // This part to be removed once __LRB__ is supported by the Larrabee compiler in 2009. +#elif defined(EA_PLATFORM_LRB) || defined(__LRB__) || (defined(__EDG__) && defined(__ICC) && defined(__x86_64__)) + #undef EA_PLATFORM_LRB + #define EA_PLATFORM_LRB 1 + #define EA_PLATFORM_NAME "Larrabee" + #define EA_PLATFORM_DESCRIPTION "Larrabee on LRB1" + #define EA_PROCESSOR_X86_64 + #if defined(BYTE_ORDER) && (BYTE_ORDER == 4321) + #define EA_SYSTEM_BIG_ENDIAN + #else + #define EA_SYSTEM_LITTLE_ENDIAN + #endif + #define EA_PROCESSOR_LRB + #define EA_PROCESSOR_LRB1 // Larrabee version 1 + #define EA_ASM_STYLE_ATT // Both types of asm style + #define EA_ASM_STYLE_INTEL // are supported. + #define EA_PLATFORM_DESKTOP + +// Android (Google phone OS) +#elif defined(EA_PLATFORM_ANDROID) || defined(__ANDROID__) + #undef EA_PLATFORM_ANDROID + #define EA_PLATFORM_ANDROID 1 + #define EA_PLATFORM_LINUX 1 + #define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "Android" + #define EA_ASM_STYLE_ATT + #if defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_PLATFORM_DESCRIPTION "Android on ARM" + #else + #error Unknown processor + #endif + #if !defined(EA_SYSTEM_BIG_ENDIAN) && !defined(EA_SYSTEM_LITTLE_ENDIAN) + #define EA_SYSTEM_LITTLE_ENDIAN + #endif + #define EA_PLATFORM_MOBILE + +// Palm OS for Mobile (Linux variant) +#elif defined(EA_PLATFORM_PALM) + #undef EA_PLATFORM_PALM + #define EA_PLATFORM_PALM 1 + #define EA_PLATFORM_LINUX 1 + #define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "Palm" + #define EA_POSIX_THREADS_AVAILABLE 1 + #define EA_ASM_STYLE_ATT + #if defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_PLATFORM_DESCRIPTION "Palm on ARM" + #else + #error Unknown processor + #endif + #if !defined(EA_SYSTEM_BIG_ENDIAN) && !defined(EA_SYSTEM_LITTLE_ENDIAN) + #define EA_SYSTEM_LITTLE_ENDIAN + #endif + #define EA_PLATFORM_MOBILE + +// Airplay +#elif defined(EA_PLATFORM_AIRPLAY) || defined(__S3E__) + #undef EA_PLATFORM_AIRPLAY + #define EA_PLATFORM_AIRPLAY + #define EA_PLATFORM_NAME "Airplay" + #if defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_PLATFORM_DESCRIPTION "Airplay on ARM" + #define EA_ASM_STYLE_ATT + #undef _MSC_VER + #elif defined(_M_IX86) || defined(I3D_ARCH_X86) + #define EA_PROCESSOR_X86 + #define EA_PLATFORM_DESCRIPTION "Airplay on x86" + #define EA_ASM_STYLE_INTEL + #else + #error Unknown processor + #endif + #if !defined(EA_SYSTEM_BIG_ENDIAN) && !defined(EA_SYSTEM_LITTLE_ENDIAN) + #if defined(HAVE_BIG_ENDIAN) || (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)) + #define EA_SYSTEM_BIG_ENDIAN + #else + #define EA_SYSTEM_LITTLE_ENDIAN + #endif + #endif + #define EA_PLATFORM_MOBILE + +// Samsung Bada OS for Mobile (Linux variant) +#elif defined(EA_PLATFORM_BADA) + #undef EA_PLATFORM_BADA + #define EA_PLATFORM_BADA 1 + //#define EA_PLATFORM_LINUX 1 // The underlying OS is Linux, but the app mostly doesn't see this. + //#define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "bada" + #define EA_ASM_STYLE_ATT + #if defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_PLATFORM_DESCRIPTION "bada on ARM" + #elif defined(__i386__) + #define EA_PLATFORM_BADA_SIMULATOR + #define EA_PROCESSOR_X86 + #define EA_PLATFORM_DESCRIPTION "bada simulator on x86" + #else + #error Unknown processor + #endif + #if !defined(EA_SYSTEM_BIG_ENDIAN) && !defined(EA_SYSTEM_LITTLE_ENDIAN) + #define EA_SYSTEM_LITTLE_ENDIAN + #endif + #define EA_PLATFORM_MOBILE + +#elif defined(__APPLE__) && __APPLE__ + #include + + // Apple family of operating systems. + #define EA_PLATFORM_APPLE + + // iPhone + // TARGET_OS_IPHONE will be undefined on an unknown compiler, and will be defined on gcc. + #if defined(EA_PLATFORM_IPHONE) || defined(__IPHONE__) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || (defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR) + #undef EA_PLATFORM_IPHONE + #define EA_PLATFORM_IPHONE 1 + #define EA_PLATFORM_NAME "iPhone" + #define EA_ASM_STYLE_ATT + #define EA_POSIX_THREADS_AVAILABLE 1 + #if defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "iPhone on ARM" + #elif defined(__i386__) + #define EA_PLATFORM_IPHONE_SIMULATOR + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "iPhone simulator on x86" + #else + #error Unknown processor + #endif + #define EA_PLATFORM_MOBILE + + // Macintosh OSX + // TARGET_OS_MAC is defined by the Metrowerks and older AppleC compilers. + // Howerver, TARGET_OS_MAC is defined to be 1 in all cases. + // __i386__ and __intel__ are defined by the GCC compiler. + // __dest_os is defined by the Metrowerks compiler. + // __MACH__ is defined by the Metrowerks and GCC compilers. + // powerc and __powerc are defined by the Metrowerks and GCC compilers. + #elif defined(EA_PLATFORM_OSX) || defined(__MACH__) || (defined(__MSL__) && (__dest_os == __mac_os_x)) + #undef EA_PLATFORM_OSX + #define EA_PLATFORM_OSX 1 + #define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "OSX" + #if defined(__i386__) || defined(__intel__) + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "OSX on x86" + #elif defined(__x86_64) || defined(__amd64) + #define EA_PROCESSOR_X86_64 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "OSX on x86-64" + #elif defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "OSX on ARM" + #elif defined(__POWERPC64__) || defined(__powerpc64__) + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_64 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "OSX on PowerPC 64" + #elif defined(__POWERPC__) || defined(__powerpc__) + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_32 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "OSX on PowerPC" + #else + #error Unknown processor + #endif + #if defined(__GNUC__) + #define EA_ASM_STYLE_ATT + #else + #define EA_ASM_STYLE_MOTOROLA + #endif + #define EA_PLATFORM_DESKTOP + + #else + #error Unknown Apple Platform + #endif + +// Linux +// __linux and __linux__ are defined by the GCC and Borland compiler. +// __i386__ and __intel__ are defined by the GCC compiler. +// __i386__ is defined by the Metrowerks compiler. +// _M_IX86 is defined by the Borland compiler. +// __sparc__ is defined by the GCC compiler. +// __powerpc__ is defined by the GCC compiler. +#elif defined(EA_PLATFORM_LINUX) || (defined(__linux) || defined(__linux__)) + #undef EA_PLATFORM_LINUX + #define EA_PLATFORM_LINUX 1 + #define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "Linux" + #if defined(__i386__) || defined(__intel__) || defined(_M_IX86) + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Linux on x86" + #elif defined(__x86_64__) + #define EA_PROCESSOR_X86_64 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Linux on x86-64" + #elif defined(__powerpc64__) + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_64 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Linux on PowerPC 64" + #elif defined(__powerpc__) + #define EA_PROCESSOR_POWERPC + #define EA_PROCESSOR_POWERPC_32 + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Linux on PowerPC" + #elif defined(__arm__) + #define EA_PROCESSOR_ARM + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Linux on ARM" + #else + #error Unknown processor + #error Unknown endianness + #endif + #if defined(__GNUC__) + #define EA_ASM_STYLE_ATT + #endif + #define EA_PLATFORM_DESKTOP + +// Win CE (Windows mobile) +#elif defined(EA_PLATFORM_WINCE) || defined(_WIN32_WCE) + #undef EA_PLATFORM_WINCE + #define EA_PLATFORM_WINCE 1 + #define EA_PLATFORM_NAME "WinCE" + #define EA_ASM_STYLE_INTEL + #define EA_SYSTEM_LITTLE_ENDIAN + #if defined(_M_ARM) // Also there is _M_ARMT + #define EA_PROCESSOR_ARM + #define EA_PLATFORM_DESCRIPTION "Windows CE on ARM" + #elif defined(_M_IX86) + #define EA_PROCESSOR_X86 + #define EA_PLATFORM_DESCRIPTION "Windows CE on X86" + #else //Possibly other Windows CE variants + #error Unknown processor + #endif + #define EA_PLATFORM_MOBILE + +// Windows +// _WIN32 is defined by the VC++, Intel and GCC compilers. +// _WIN64 is defined by the VC++, Intel and GCC compilers. +// __WIN32__ is defined by the Borland compiler. +// __INTEL__ is defined by the Metrowerks compiler. +// _M_IX86, _M_AMD64 and _M_IA64 are defined by the VC++, Intel, and Borland compilers. +// _X86_, _AMD64_, and _IA64_ are defined by the Metrowerks compiler. +// _M_ARM is defined by the VC++ compiler. +#elif (defined(EA_PLATFORM_WINDOWS) || (defined(_WIN32) || defined(__WIN32__) || defined(_WIN64) || (defined(__MWERKS__) && defined(_X86_)))) && !defined(_XBOX) + #undef EA_PLATFORM_WINDOWS + #define EA_PLATFORM_WINDOWS 1 + #define EA_PLATFORM_NAME "Windows" + #ifdef _WIN64 // VC++ defines both _WIN32 and _WIN64 when compiling for Win64. + #define EA_PLATFORM_WIN64 + #else + #define EA_PLATFORM_WIN32 + #endif + #if defined(_M_AMD64) || defined(_AMD64_) || defined(__x86_64__) + #define EA_PROCESSOR_X86_64 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Windows on X86-64" + #elif defined(_M_IX86) || defined(_X86_) + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Windows on X86" + #elif defined(_M_IA64) || defined(_IA64_) + #define EA_PROCESSOR_IA64 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Windows on IA-64" + #elif defined(_M_ARM) + #define EA_PROCESSOR_ARM + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "Windows CE on ARM" + #else //Possibly other Windows CE variants + #error Unknown processor + #error Unknown endianness + #endif + #if defined(__GNUC__) + #define EA_ASM_STYLE_ATT + #elif defined(_MSC_VER) || defined(__BORLANDC__) || defined(__ICL) + #define EA_ASM_STYLE_INTEL + #endif + #define EA_PLATFORM_DESKTOP + #define EA_PLATFORM_MICROSOFT 1 + +// Sun (Solaris) +// __SUNPRO_CC is defined by the Sun compiler. +// __sun is defined by the GCC compiler. +// __i386 is defined by the Sun and GCC compilers. +// __sparc is defined by the Sun and GCC compilers. +#elif defined(EA_PLATFORM_SUN) || (defined(__SUNPRO_CC) || defined(__sun)) + #undef EA_PLATFORM_SUN + #define EA_PLATFORM_SUN 1 + #define EA_PLATFORM_UNIX 1 + #define EA_PLATFORM_NAME "SUN" + #if defined(__i386) + #define EA_PROCESSOR_X86 + #define EA_SYSTEM_LITTLE_ENDIAN + #define EA_PLATFORM_DESCRIPTION "SUN on x86" + #elif defined(__sparc) + #define EA_PROCESSOR_SPARC + #define EA_SYSTEM_BIG_ENDIAN + #define EA_PLATFORM_DESCRIPTION "SUN on Sparc" + #else + #error Unknown processor + #error Unknown endianness + #endif + #define EA_PLATFORM_DESKTOP + +#else + #error Unknown platform + #error Unknown processor + #error Unknown endianness +#endif + + + +// EA_PLATFORM_PTR_SIZE +// Platform pointer size; same as sizeof(void*). +// This is not the same as sizeof(int), as int is usually 32 bits on +// even 64 bit platforms. +// +// _WIN64 is defined by Win64 compilers, such as VC++. +// _M_IA64 is defined by VC++ and Intel compilers for IA64 processors. +// __LP64__ is defined by HP compilers for the LP64 standard. +// _LP64 is defined by the GCC and Sun compilers for the LP64 standard. +// __ia64__ is defined by the GCC compiler for IA64 processors. +// __arch64__ is defined by the Sparc compiler for 64 bit processors. +// __mips64__ is defined by the GCC compiler for MIPS processors. +// __powerpc64__ is defined by the GCC compiler for PowerPC processors. +// __64BIT__ is defined by the AIX compiler for 64 bit processors. +// __sizeof_ptr is defined by the ARM compiler (armcc, armcpp). +// +#ifndef EA_PLATFORM_PTR_SIZE + #if defined(__WORDSIZE) // Defined by some variations of GCC. + #define EA_PLATFORM_PTR_SIZE ((__WORDSIZE) / 8) + #elif defined(_WIN64) || defined(__LP64__) || defined(_LP64) || defined(_M_IA64) || defined(__ia64__) || defined(__arch64__) || defined(__mips64__) || defined(__64BIT__) + #define EA_PLATFORM_PTR_SIZE 8 + #elif defined(__CC_ARM) && (__sizeof_ptr == 8) + #define EA_PLATFORM_PTR_SIZE 8 + #else + #define EA_PLATFORM_PTR_SIZE 4 + #endif +#endif + + + +// EA_PLATFORM_WORD_SIZE +// This defines the size of a machine word. This will be the same as +// the size of registers on the machine but not necessarily the same +// as the size of pointers on the machine. A number of 64 bit platforms +// have 64 bit registers but 32 bit pointers. +// +#ifndef EA_PLATFORM_WORD_SIZE + #if defined(EA_PLATFORM_XENON) || defined(EA_PLATFORM_PS3) + #define EA_PLATFORM_WORD_SIZE 8 + #else + #define EA_PLATFORM_WORD_SIZE EA_PLATFORM_PTR_SIZE + #endif +#endif + + + +// Disabled until and unless deemed useful: +// +// Platform integer types +// These definitions allow us to define other things properly, such as +// sized integer types. In order to bring some order to this chaos, +// we follow a variation of the standard LP64 conventions defined at: +// http://www.opengroup.org/public/tech/aspen/lp64_wp.htm +// +// #if defined(EA_PLATFORM_LINUX) || defined(EA_PLATFORM_OSX) || defined(EA_PLATFORM_XBOX) || defined(EA_PLATFORM_XENON) +// #define EA_PLATFORM_ILP32_LL64 // int, long, ptr = 32 bits; long long = 64 bits. +// +// #elif defined(EA_PLATFORM_SUN) || defined(EA_PLATFORM_SGI) +// #if (EA_PLATFORM_WORD_SIZE == 32) +// #define ILP32_LL64 // int, long, ptr = 32 bits; long long = 64 bits. +// #else // 64 bit platform +// #define EA_PLATFORM_I32_LLLP64 // int = 32 bits; long, long long, ptr = 64 bits. +// #endif +// +// #elif defined(EA_PLATFORM_WINDOWS) +// #if (EA_PLATFORM_WORD_SIZE == 32) +// #define ILP32_LL64 // int, long, ptr = 32 bits; long long = 64 bits. +// #else // 64 bit platform +// #if defined(__MWERKS__) || defined(__GNUC__) +// #define EA_PLATFORM_I32_LLLP64 // int = 32 bits; long, long long, ptr = 64 bits. +// #else // MSVC +// #define EA_PLATFORM_IL32_LLP64 // int, long = 32 bits; long long, ptr = 64 bits. +// #endif +// #endif +// #endif + + +#endif // INCLUDED_eaplatform_H + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EABase/eabase.h b/lib/eastl/include/EABase/eabase.h new file mode 100644 index 0000000..534f508 --- /dev/null +++ b/lib/eastl/include/EABase/eabase.h @@ -0,0 +1,876 @@ +/* +Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*----------------------------------------------------------------------------- + * eabase.h + * + * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. + * Maintained by Paul Pedriana, Maxis + *---------------------------------------------------------------------------*/ + + +#ifndef INCLUDED_eabase_H +#define INCLUDED_eabase_H + + +// Identify the compiler and declare the EA_COMPILER_xxxx defines +#ifndef INCLUDED_eacompiler_H +# include "EABase/config/eacompiler.h" +#endif + +// Identify traits which this compiler supports, or does not support +#ifndef INCLUDED_eacompilertraits_H +# include "EABase/config/eacompilertraits.h" +#endif + +// Identify the platform and declare the EA_xxxx defines +#ifndef INCLUDED_eaplatform_H +# include "EABase/config/eaplatform.h" +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EABASE_VERSION +// +// We more or less follow the conventional EA packaging approach to versioning +// here. A primary distinction here is that minor versions are defined as two +// digit entities (e.g. .03") instead of minimal digit entities ".3"). The logic +// here is that the value is a counter and not a floating point fraction. +// Note that the major version doesn't have leading zeros. +// +// Example version strings: +// "0.91.00" // Major version 0, minor version 91, patch version 0. +// "1.00.00" // Major version 1, minor and patch version 0. +// "3.10.02" // Major version 3, minor version 10, patch version 02. +// "12.03.01" // Major version 12, minor version 03, patch version +// +// Example usage: +// printf("EABASE version: %s", EABASE_VERSION); +// printf("EABASE version: %d.%d.%d", EABASE_VERSION_N / 10000 % 100, EABASE_VERSION_N / 100 % 100, EABASE_VERSION_N % 100); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EABASE_VERSION +# define EABASE_VERSION "2.00.22" +# define EABASE_VERSION_N 20022 +#endif + + + +// ------------------------------------------------------------------------ +// The C++ standard defines size_t as a built-in type. Some compilers are +// not standards-compliant in this respect, so we need an additional include. +// The case is similar with wchar_t under C++. + +#if defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_MSVC) || defined(EA_WCHAR_T_NON_NATIVE) +# include +#endif + + +// ------------------------------------------------------------------------ +// Ensure this header file is only processed once (with certain compilers) +// GCC doesn't need such a pragma because it has special recognition for +// include guards (such as that above) and effectively implements the same +// thing without having to resort to non-portable pragmas. It is possible +// that the decision to use pragma once here is ill-advised, perhaps because +// some compilers masquerade as MSVC but don't implement all features. +#if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_METROWERKS) +# pragma once +#endif + + +// ------------------------------------------------------------------------ +// By default, GCC on certain platforms defines NULL as ((void*)0), which is the +// C definition. This causes all sort of problems for C++ code, so it is +// worked around by undefining NULL. + +#if defined(NULL) +# undef NULL +#endif + + +// ------------------------------------------------------------------------ +// Define the NULL pointer. This is normally defined in , but we +// don't want to force a global dependency on that header, so the definition +// is duplicated here. + +#if defined(__cplusplus) +# define NULL 0 +#else +# define NULL ((void*)0) +#endif + + +// ------------------------------------------------------------------------ +// C98/99 Standard typedefs. From the ANSI ISO/IEC 9899 standards document +// Most recent versions of the gcc-compiler come with these defined in +// inttypes.h or stddef.h. Determining if they are predefined can be +// tricky, so we expect some problems on non-standard compilers + +// ------------------------------------------------------------------------ +// We need to test this after we potentially include stddef.h, otherwise we +// would have put this into the compilertraits header. +#if !defined(EA_COMPILER_HAS_INTTYPES) && (!defined(_MSC_VER) || (_MSC_VER > 1500)) && (defined(EA_COMPILER_IS_C99) || defined(INT8_MIN) || defined(EA_COMPILER_HAS_C99_TYPES) || defined(_SN_STDINT_H)) +# define EA_COMPILER_HAS_INTTYPES +#endif + + +#ifdef EA_COMPILER_HAS_INTTYPES // If the compiler supports inttypes... + // ------------------------------------------------------------------------ + // Include the stdint header to define and derive the required types. + // Additionally include inttypes.h as many compilers, including variations + // of GCC define things in inttypes.h that the C99 standard says goes + // in stdint.h. + // + // The C99 standard specifies that inttypes.h only define printf/scanf + // format macros if __STDC_FORMAT_MACROS is defined before #including + // inttypes.h. For consistency, we do that here. +# ifndef __STDC_FORMAT_MACROS +# define __STDC_FORMAT_MACROS +# endif +# if !defined(__psp__) && defined(__GNUC__) // The GCC compiler defines standard int types (e.g. uint32_t) but not PRId8, etc. +# include // PRId8, SCNd8, etc. +# endif +# include // int32_t, INT64_C, UINT8_MAX, etc. +# include // float_t, double_t, etc. +# include // FLT_EVAL_METHOD. + +# if !defined(FLT_EVAL_METHOD) && (defined(__FLT_EVAL_METHOD__) || defined(_FEVAL)) // GCC 3.x defines __FLT_EVAL_METHOD__ instead of the C99 standard FLT_EVAL_METHOD. +# ifdef __FLT_EVAL_METHOD__ +# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ +# else +# define FLT_EVAL_METHOD _FEVAL +# endif +# endif + + // MinGW GCC (up to at least v4.3.0-20080502) mistakenly neglects to define float_t and double_t. + // This appears to be an acknowledged bug as of March 2008 and is scheduled to be fixed. + // Similarly, Android uses a mix of custom standard library headers which don't define float_t and double_t. +# if defined(__MINGW32__) || defined(EA_PLATFORM_ANDROID) +# if defined(__FLT_EVAL_METHOD__) +# if(__FLT_EVAL_METHOD__== 0) + typedef float float_t; + typedef double double_t; +# elif(__FLT_EVAL_METHOD__ == 1) + typedef double float_t; + typedef double double_t; +# elif(__FLT_EVAL_METHOD__ == 2) + typedef long double float_t; + typedef long double double_t; +# endif +# else + typedef float float_t; + typedef double double_t; +# endif +# endif + + // Airplay's pretty broken for these types (at least as of 4.1) +# if defined __S3E__ + + typedef float float_t; + typedef double double_t; + +# undef INT32_C +# undef UINT32_C +# undef INT64_C +# undef UINT64_C +# define INT32_C(x) x##L +# define UINT32_C(x) x##UL +# define INT64_C(x) x##LL +# define UINT64_C(x) x##ULL + +# define EA_PRI_64_LENGTH_SPECIFIER "ll" +# define EA_SCN_64_LENGTH_SPECIFIER "ll" + +# define SCNd16 "hd" +# define SCNi16 "hi" +# define SCNo16 "ho" +# define SCNu16 "hu" +# define SCNx16 "hx" + +# define SCNd32 "d" // This works for both 32 bit and 64 bit systems, as we assume LP64 conventions. +# define SCNi32 "i" +# define SCNo32 "o" +# define SCNu32 "u" +# define SCNx32 "x" + +# define SCNd64 EA_SCN_64_LENGTH_SPECIFIER "d" +# define SCNi64 EA_SCN_64_LENGTH_SPECIFIER "i" +# define SCNo64 EA_SCN_64_LENGTH_SPECIFIER "o" +# define SCNu64 EA_SCN_64_LENGTH_SPECIFIER "u" +# define SCNx64 EA_SCN_64_LENGTH_SPECIFIER "x" + +# define PRIdPTR PRId32 // Usage of pointer values will generate warnings with +# define PRIiPTR PRIi32 // some compilers because they are defined in terms of +# define PRIoPTR PRIo32 // integers. However, you can't simply use "p" because +# define PRIuPTR PRIu32 // 'p' is interpreted in a specific and often different +# define PRIxPTR PRIx32 // way by the library. +# define PRIXPTR PRIX32 + +# define PRId8 "hhd" +# define PRIi8 "hhi" +# define PRIo8 "hho" +# define PRIu8 "hhu" +# define PRIx8 "hhx" +# define PRIX8 "hhX" + +# define PRId16 "hd" +# define PRIi16 "hi" +# define PRIo16 "ho" +# define PRIu16 "hu" +# define PRIx16 "hx" +# define PRIX16 "hX" + +# define PRId32 "d" // This works for both 32 bit and 64 bit systems, as we assume LP64 conventions. +# define PRIi32 "i" +# define PRIo32 "o" +# define PRIu32 "u" +# define PRIx32 "x" +# define PRIX32 "X" + +# define PRId64 EA_PRI_64_LENGTH_SPECIFIER "d" +# define PRIi64 EA_PRI_64_LENGTH_SPECIFIER "i" +# define PRIo64 EA_PRI_64_LENGTH_SPECIFIER "o" +# define PRIu64 EA_PRI_64_LENGTH_SPECIFIER "u" +# define PRIx64 EA_PRI_64_LENGTH_SPECIFIER "x" +# define PRIX64 EA_PRI_64_LENGTH_SPECIFIER "X" +# endif + + // The CodeSourcery definitions of PRIxPTR and SCNxPTR are broken for 32 bit systems. +# if defined(__SIZEOF_SIZE_T__) && (__SIZEOF_SIZE_T__ == 4) && (defined(__have_long64) || defined(__have_longlong64) || defined(__S3E__)) +# undef PRIdPTR +# define PRIdPTR "d" +# undef PRIiPTR +# define PRIiPTR "i" +# undef PRIoPTR +# define PRIoPTR "o" +# undef PRIuPTR +# define PRIuPTR "u" +# undef PRIxPTR +# define PRIxPTR "x" +# undef PRIXPTR +# define PRIXPTR "X" + +# undef SCNdPTR +# define SCNdPTR "d" +# undef SCNiPTR +# define SCNiPTR "i" +# undef SCNoPTR +# define SCNoPTR "o" +# undef SCNuPTR +# define SCNuPTR "u" +# undef SCNxPTR +# define SCNxPTR "x" +# endif +#else // else we must implement types ourselves. + +# if !defined(__S3E__) +# if !defined(__BIT_TYPES_DEFINED__) && !defined(__int8_t_defined) + typedef signed char int8_t; //< 8 bit signed integer +# endif +# if !defined( __int8_t_defined ) + typedef signed short int16_t; //< 16 bit signed integer + typedef signed int int32_t; //< 32 bit signed integer. This works for both 32 bit and 64 bit platforms, as we assume the LP64 is followed. +# define __int8_t_defined +# endif + typedef unsigned char uint8_t; //< 8 bit unsigned integer + typedef unsigned short uint16_t; //< 16 bit unsigned integer +# if !defined( __uint32_t_defined ) + typedef unsigned int uint32_t; //< 32 bit unsigned integer. This works for both 32 bit and 64 bit platforms, as we assume the LP64 is followed. +# define __uint32_t_defined +# endif +# endif + + // According to the C98/99 standard, FLT_EVAL_METHOD defines control the + // width used for floating point _t types. +# if defined(__MWERKS__) && ((defined(_MSL_C99) && (_MSL_C99 == 1)) || (__MWERKS__ < 0x4000)) + // Metrowerks defines FLT_EVAL_METHOD and + // float_t/double_t under this condition. +# elif defined(FLT_EVAL_METHOD) +# if (FLT_EVAL_METHOD == 0) + typedef float float_t; + typedef double double_t; +# elif (FLT_EVAL_METHOD == 1) + typedef double float_t; + typedef double double_t; +# elif (FLT_EVAL_METHOD == 2) + typedef long double float_t; + typedef long double double_t; +# endif +# else +# define FLT_EVAL_METHOD 0 + typedef float float_t; + typedef double double_t; +# endif + +# if defined(EA_PLATFORM_LINUX) || defined(EA_PLATFORM_PS3) || defined(EA_PLATFORM_PS3_SPU) + typedef signed long long int64_t; + typedef unsigned long long uint64_t; + +# elif defined(EA_PLATFORM_SUN) || defined(EA_PLATFORM_SGI) +# if (EA_PLATFORM_PTR_SIZE == 4) + typedef signed long long int64_t; + typedef unsigned long long uint64_t; +# else + typedef signed long int64_t; + typedef unsigned long uint64_t; +# endif + +# elif defined(EA_PLATFORM_WINDOWS) || defined(EA_PLATFORM_XBOX) || defined(EA_PLATFORM_XENON) || defined(EA_PLATFORM_MAC) +# if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_BORLAND) || defined(EA_COMPILER_INTEL) + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; +# else // GCC, Metrowerks, etc. + typedef long long int64_t; + typedef unsigned long long uint64_t; +# endif +# elif defined(EA_PLATFORM_AIRPLAY) +# else + typedef signed long long int64_t; + typedef unsigned long long uint64_t; +# endif + + + // ------------------------------------------------------------------------ + // macros for declaring constants in a portable way. + // + // e.g. int64_t x = INT64_C(1234567812345678); + // e.g. int64_t x = INT64_C(0x1111111122222222); + // e.g. uint64_t x = UINT64_C(0x1111111122222222); + +# ifndef INT8_C_DEFINED // If the user hasn't already defined these... +# define INT8_C_DEFINED + + // VC++ 7.0 and earlier don't handle the LL suffix. +# if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_BORLAND) +# ifndef INT8_C +# define INT8_C(x) int8_t(x) // x##i8 doesn't work satisfactorilly because -128i8 generates an out of range warning. +# endif +# ifndef UINT8_C +# define UINT8_C(x) uint8_t(x) +# endif +# ifndef INT16_C +# define INT16_C(x) int16_t(x) // x##i16 doesn't work satisfactorilly because -32768i8 generates an out of range warning. +# endif +# ifndef UINT16_C +# define UINT16_C(x) uint16_t(x) +# endif +# ifndef INT32_C +# define INT32_C(x) x##i32 +# endif +# ifndef UINT32_C +# define UINT32_C(x) x##ui32 +# endif +# ifndef INT64_C +# define INT64_C(x) x##i64 +# endif +# ifndef UINT64_C +# define UINT64_C(x) x##ui64 +# endif + +# elif !defined(__STDC_CONSTANT_MACROS) // __STDC_CONSTANT_MACROS is defined by GCC 3 and later when INT8_C(), etc. are defined. +# define INT8_C(x) int8_t(x) // For the majority of compilers and platforms, long is 32 bits and long long is 64 bits. +# define UINT8_C(x) uint8_t(x) +# define INT16_C(x) int16_t(x) +# define UINT16_C(x) uint16_t(x) // Possibly we should make this be uint16_t(x##u). Let's see how compilers react before changing this. +# if defined(EA_PLATFORM_PS3) // PS3 defines long as 64 bit, so we cannot use any size suffix. +# define INT32_C(x) int32_t(x) +# define UINT32_C(x) uint32_t(x) +# else // Else we are working on a platform whereby sizeof(long) == sizeof(int32_t). +# define INT32_C(x) x##L +# define UINT32_C(x) x##UL +# endif +# define INT64_C(x) x##LL // The way to deal with this is to compare ULONG_MAX to 0xffffffff and if not equal, then remove the L. +# define UINT64_C(x) x##ULL // We need to follow a similar approach for LL. +# endif +# endif + + // ------------------------------------------------------------------------ + // type sizes +# ifndef INT8_MAX_DEFINED // If the user hasn't already defined these... +# define INT8_MAX_DEFINED + + // The value must be 2^(n-1)-1 +# ifndef INT8_MAX +# define INT8_MAX 127 +# endif +# ifndef INT16_MAX +# define INT16_MAX 32767 +# endif +# ifndef INT32_MAX +# define INT32_MAX 2147483647 +# endif +# ifndef INT64_MAX +# define INT64_MAX INT64_C(9223372036854775807) +# endif + + // The value must be either -2^(n-1) or 1-2(n-1). +# ifndef INT8_MIN +# define INT8_MIN -128 +# endif +# ifndef INT16_MIN +# define INT16_MIN -32768 +# endif +# ifndef INT32_MIN +# define INT32_MIN (-INT32_MAX - 1) // -2147483648 +# endif +# ifndef INT64_MIN +# define INT64_MIN (-INT64_MAX - 1) // -9223372036854775808 +# endif + + // The value must be 2^n-1 +# ifndef UINT8_MAX +# define UINT8_MAX 0xffU // 255 +# endif +# ifndef UINT16_MAX +# define UINT16_MAX 0xffffU // 65535 +# endif +# ifndef UINT32_MAX +# define UINT32_MAX UINT32_C(0xffffffff) // 4294967295 +# endif +# ifndef UINT64_MAX +# define UINT64_MAX UINT64_C(0xffffffffffffffff) // 18446744073709551615 +# endif +# endif + + // ------------------------------------------------------------------------ + // sized printf and scanf format specifiers + // See the C99 standard, section 7.8.1 -- Macros for format specifiers. + // + // The C99 standard specifies that inttypes.h only define printf/scanf + // format macros if __STDC_FORMAT_MACROS is defined before #including + // inttypes.h. For consistency, we define both __STDC_FORMAT_MACROS and + // the printf format specifiers here. We also skip the "least/most" + // variations of these specifiers, as we've decided to do so with + // basic types. + // + // For 64 bit systems, we assume the LP64 standard is followed + // (as opposed to ILP64, etc.) For 32 bit systems, we assume the + // ILP32 standard is followed. See: + // http://www.opengroup.org/public/tech/aspen/lp64_wp.htm + // for information about this. Thus, on both 32 and 64 bit platforms, + // %l refers to 32 bit data while %ll refers to 64 bit data. + +# ifndef __STDC_FORMAT_MACROS +# define __STDC_FORMAT_MACROS +# endif + +# if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_BORLAND) // VC++ 7.1+ understands long long as a data type but doesn't accept %ll as a printf specifier. +# define EA_PRI_64_LENGTH_SPECIFIER "I64" +# define EA_SCN_64_LENGTH_SPECIFIER "I64" +# else +# define EA_PRI_64_LENGTH_SPECIFIER "ll" +# define EA_SCN_64_LENGTH_SPECIFIER "ll" +# endif // It turns out that some platforms use %q to represent a 64 bit value, but these are not relevant to us at this time. + + // Printf format specifiers +# if defined(EA_COMPILER_IS_C99) || defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_METROWERKS) // || defined(EA_COMPILER_INTEL) ? +# define PRId8 "hhd" +# define PRIi8 "hhi" +# define PRIo8 "hho" +# define PRIu8 "hhu" +# define PRIx8 "hhx" +# define PRIX8 "hhX" +# else // VC++, Borland, etc. which have no way to specify 8 bit values other than %c. +# define PRId8 "c" // This may not work properly but it at least will not crash. Try using 16 bit versions instead. +# define PRIi8 "c" // " +# define PRIo8 "o" // " +# define PRIu8 "u" // " +# define PRIx8 "x" // " +# define PRIX8 "X" // " +# endif + +# define PRId16 "hd" +# define PRIi16 "hi" +# define PRIo16 "ho" +# define PRIu16 "hu" +# define PRIx16 "hx" +# define PRIX16 "hX" + +# define PRId32 "d" // This works for both 32 bit and 64 bit systems, as we assume LP64 conventions. +# define PRIi32 "i" +# define PRIo32 "o" +# define PRIu32 "u" +# define PRIx32 "x" +# define PRIX32 "X" + +# define PRId64 EA_PRI_64_LENGTH_SPECIFIER "d" +# define PRIi64 EA_PRI_64_LENGTH_SPECIFIER "i" +# define PRIo64 EA_PRI_64_LENGTH_SPECIFIER "o" +# define PRIu64 EA_PRI_64_LENGTH_SPECIFIER "u" +# define PRIx64 EA_PRI_64_LENGTH_SPECIFIER "x" +# define PRIX64 EA_PRI_64_LENGTH_SPECIFIER "X" + +# if (EA_PLATFORM_PTR_SIZE == 4) +# define PRIdPTR PRId32 // Usage of pointer values will generate warnings with +# define PRIiPTR PRIi32 // some compilers because they are defined in terms of +# define PRIoPTR PRIo32 // integers. However, you can't simply use "p" because +# define PRIuPTR PRIu32 // 'p' is interpreted in a specific and often different +# define PRIxPTR PRIx32 // way by the library. +# define PRIXPTR PRIX32 +# elif (EA_PLATFORM_PTR_SIZE == 8) +# define PRIdPTR PRId64 +# define PRIiPTR PRIi64 +# define PRIoPTR PRIo64 +# define PRIuPTR PRIu64 +# define PRIxPTR PRIx64 +# define PRIXPTR PRIX64 +# endif + + // Scanf format specifiers +# if defined(EA_COMPILER_IS_C99) || defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_METROWERKS) // || defined(EA_COMPILER_INTEL) ? +# define SCNd8 "hhd" +# define SCNi8 "hhi" +# define SCNo8 "hho" +# define SCNu8 "hhu" +# define SCNx8 "hhx" +# else // VC++, Borland, etc. which have no way to specify 8 bit values other than %c. +# define SCNd8 "c" // This will not work properly but it at least will not crash. Try using 16 bit versions instead. +# define SCNi8 "c" // " +# define SCNo8 "c" // " +# define SCNu8 "c" // " +# define SCNx8 "c" // " +# endif + +# define SCNd16 "hd" +# define SCNi16 "hi" +# define SCNo16 "ho" +# define SCNu16 "hu" +# define SCNx16 "hx" + +# define SCNd32 "d" // This works for both 32 bit and 64 bit systems, as we assume LP64 conventions. +# define SCNi32 "i" +# define SCNo32 "o" +# define SCNu32 "u" +# define SCNx32 "x" + +# define SCNd64 EA_SCN_64_LENGTH_SPECIFIER "d" +# define SCNi64 EA_SCN_64_LENGTH_SPECIFIER "i" +# define SCNo64 EA_SCN_64_LENGTH_SPECIFIER "o" +# define SCNu64 EA_SCN_64_LENGTH_SPECIFIER "u" +# define SCNx64 EA_SCN_64_LENGTH_SPECIFIER "x" + +# if (EA_PLATFORM_PTR_SIZE == 4) +# define SCNdPTR SCNd32 // Usage of pointer values will generate warnings with +# define SCNiPTR SCNi32 // some compilers because they are defined in terms of +# define SCNoPTR SCNo32 // integers. However, you can't simply use "p" because +# define SCNuPTR SCNu32 // 'p' is interpreted in a specific and often different +# define SCNxPTR SCNx32 // way by the library. +# elif (EA_PLATFORM_PTR_SIZE == 8) +# define SCNdPTR SCNd64 +# define SCNiPTR SCNi64 +# define SCNoPTR SCNo64 +# define SCNuPTR SCNu64 +# define SCNxPTR SCNx64 +# endif + +#endif + + +// ------------------------------------------------------------------------ +// bool8_t +// The definition of a bool8_t is controversial with some, as it doesn't +// act just like built-in bool. For example, you can assign -100 to it. +// +#ifndef BOOL8_T_DEFINED // If the user hasn't already defined this... +# define BOOL8_T_DEFINED +# if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_METROWERKS) || (defined(EA_COMPILER_INTEL) && defined(EA_PLATFORM_WINDOWS)) || defined(EA_COMPILER_BORLAND) +# if defined(__cplusplus) + typedef bool bool8_t; +# else + typedef int8_t bool8_t; +# endif +# else // EA_COMPILER_GNUC generally uses 4 bytes per bool. + typedef int8_t bool8_t; +# endif +#endif + + +// ------------------------------------------------------------------------ +// intptr_t / uintptr_t +// Integer type guaranteed to be big enough to hold +// a native pointer ( intptr_t is defined in STDDEF.H ) +// +#if !defined(_INTPTR_T_DEFINED) && !defined(_intptr_t_defined) && !defined(EA_COMPILER_HAS_C99_TYPES) +# if (EA_PLATFORM_PTR_SIZE == 4) + typedef int32_t intptr_t; +# elif (EA_PLATFORM_PTR_SIZE == 8) + typedef int64_t intptr_t; +# endif + +# define _intptr_t_defined +# define _INTPTR_T_DEFINED +#endif + +#if !defined(_UINTPTR_T_DEFINED) && !defined(_uintptr_t_defined) && !defined(EA_COMPILER_HAS_C99_TYPES) +# if (EA_PLATFORM_PTR_SIZE == 4) + typedef uint32_t uintptr_t; +# elif (EA_PLATFORM_PTR_SIZE == 8) + typedef uint64_t uintptr_t; +# endif + +# define _uintptr_t_defined +# define _UINTPTR_T_DEFINED +#endif + +#if !defined(EA_COMPILER_HAS_INTTYPES) +# ifndef INTMAX_T_DEFINED +# define INTMAX_T_DEFINED + + // At this time, all supported compilers have int64_t as the max + // integer type. Some compilers support a 128 bit inteter type, + // but in those cases it is not a true int128_t but rather a + // crippled data type. + typedef int64_t intmax_t; + typedef uint64_t uintmax_t; +# endif +#endif + + +// ------------------------------------------------------------------------ +// ssize_t +// signed equivalent to size_t. +// This is defined by GCC but not by other compilers. +// +#if !defined(__GNUC__) + // As of this writing, all non-GCC compilers significant to us implement + // uintptr_t the same as size_t. However, this isn't guaranteed to be + // so for all compilers, as size_t may be based on int, long, or long long. +# if defined(_MSC_VER) && (EA_PLATFORM_PTR_SIZE == 8) + typedef __int64 ssize_t; +# elif !defined(__S3E__) + typedef long ssize_t; +# endif +#elif defined(EA_PLATFORM_UNIX) || defined(EA_PLATFORM_MINGW) || defined(__APPLE__) || defined(_BSD_SIZE_T_) // _BSD_SIZE_T_ indicates that Unix-like headers are present, even though it may not be a true Unix platform. +# include +#endif + + +// ------------------------------------------------------------------------ +// Character types + +#if defined(EA_COMPILER_MSVC) || defined(EA_COMPILER_BORLAND) +# if defined(EA_WCHAR_T_NON_NATIVE) + // In this case, wchar_t is not defined unless we include + // wchar.h or if the compiler makes it built-in. +# ifdef EA_COMPILER_MSVC +# pragma warning(push, 3) +# endif +# include +# ifdef EA_COMPILER_MSVC +# pragma warning(pop) +# endif +# endif +#endif + + +// ------------------------------------------------------------------------ +// char8_t -- Guaranteed to be equal to the compiler's char data type. +// Some compilers implement char8_t as unsigned, though char +// is usually set to be signed. +// +// char16_t -- This is set to be an unsigned 16 bit value. If the compiler +// has wchar_t as an unsigned 16 bit value, then char16_t is +// set to be the same thing as wchar_t in order to allow the +// user to use char16_t with standard wchar_t functions. +// +// char32_t -- This is set to be an unsigned 32 bit value. If the compiler +// has wchar_t as an unsigned 32 bit value, then char32_t is +// set to be the same thing as wchar_t in order to allow the +// user to use char32_t with standard wchar_t functions. +// +// VS2010 unilaterally defines char16_t and char32_t in its yvals.h header +// unless _HAS_CHAR16_T_LANGUAGE_SUPPORT or _CHAR16T are defined. +// However, VS2010 does not support the C++0x u"" and U"" string literals, +// which makes its definition of char16_t and char32_t somewhat useless. +// Until VC++ supports string literals, the buildystems should define +// _CHAR16T and let EABase define char16_t and EA_CHAR16. +// +// GCC defines char16_t and char32_t in the C compiler in -std=gnu99 mode, +// as __CHAR16_TYPE__ and __CHAR32_TYPE__, and for the C++ compiler +// in -std=c++0x and -std=gnu++0x modes, as char16_t and char32_t too. + +#if !defined(EA_CHAR16_NATIVE) +# if defined(_MSC_VER) && (_MSC_VER >= 1600) && defined(_CHAR16T) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT) // VS2010+ +# define EA_CHAR16_NATIVE 1 +# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 404) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(__STDC_VERSION__)) // g++ (C++ compiler) 4.4+ with -std=c++0x or gcc (C compiler) 4.4+ with -std=gnu99 +# define EA_CHAR16_NATIVE 1 +# else +# define EA_CHAR16_NATIVE 0 +# endif +#endif + +#if !defined(EA_CHAR32_NATIVE) +# if defined(_MSC_VER) && (_MSC_VER >= 1600) && defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT // VS2010+ +# define EA_CHAR32_NATIVE 1 +# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 404) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(__STDC_VERSION__)) // g++ (C++ compiler) 4.4+ with -std=c++0x or gcc (C compiler) 4.4+ with -std=gnu99 +# define EA_CHAR32_NATIVE 1 +# else +# define EA_CHAR32_NATIVE 0 +# endif +#endif + + +#ifndef CHAR8_T_DEFINED // If the user hasn't already defined these... +# define CHAR8_T_DEFINED + +# if EA_CHAR16_NATIVE + typedef char char8_t; + + // In C++, char16_t and char32_t are already defined by the compiler. + // In MS C, char16_t and char32_t are already defined by the compiler/standard library. + // In GCC C, __CHAR16_TYPE__ and __CHAR32_TYPE__ are defined instead, and we must define char16_t and char32_t from these. +# if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(__CHAR16_TYPE__) // If using GCC and compiling in C... + typedef __CHAR16_TYPE__ char16_t; + typedef __CHAR32_TYPE__ char32_t; +# endif +# elif defined(EA_COMPILER_HAS_CHAR_16_32) + typedef char char8_t; +# elif (EA_WCHAR_SIZE == 2) +# define _CHAR16T + typedef char char8_t; + typedef wchar_t char16_t; + typedef uint32_t char32_t; +# else + typedef char char8_t; + typedef uint16_t char16_t; + typedef wchar_t char32_t; +# endif +#endif + + +// EA_CHAR16 / EA_CHAR32 +// +// Supports usage of portable string constants. +// +// Example usage: +// const char16_t* str = EA_CHAR16("Hello world"); +// const char32_t* str = EA_CHAR32("Hello world"); +// const char16_t c = EA_CHAR16('\x3001'); +// const char32_t c = EA_CHAR32('\x3001'); +// +#ifndef EA_CHAR16 +# if EA_CHAR16_NATIVE && !defined(_MSC_VER) // Microsoft doesn't support char16_t string literals. +# define EA_CHAR16(s) u ## s +# elif (EA_WCHAR_SIZE == 2) +# define EA_CHAR16(s) L ## s +# else + //#define EA_CHAR16(s) // Impossible to implement. +# endif +#endif + +#ifndef EA_CHAR32 +# if EA_CHAR32_NATIVE && !defined(_MSC_VER) // Microsoft doesn't support char32_t string literals. +# define EA_CHAR32(s) U ## s +# elif (EA_WCHAR_SIZE == 2) + //#define EA_CHAR32(s) // Impossible to implement. +# else +# define EA_CHAR32(s) L ## s +# endif +#endif + + +// ------------------------------------------------------------------------ +// EAArrayCount +// +// Returns the count of items in a built-in C array. This is a common technique +// which is often used to help properly calculate the number of items in an +// array at runtime in order to prevent overruns, etc. +// +// Example usage: +// int array[75]; +// size_t arrayCount = EAArrayCount(array); // arrayCount is 75. +// +#ifndef EAArrayCount +# define EAArrayCount(x) (sizeof(x) / sizeof(x[0])) +#endif + + +// ------------------------------------------------------------------------ +// static_assert +// +// C++0x static_assert (a.k.a. compile-time assert). +// +// Specification: +// void static_assert(bool const_expression, const char* description); +// +// Example usage: +// static_assert(sizeof(int) == 4, "int must be 32 bits"); +// +#if !defined(EABASE_STATIC_ASSERT_ENABLED) +# if defined(EA_DEBUG) || defined(_DEBUG) +# define EABASE_STATIC_ASSERT_ENABLED 1 +# else +# define EABASE_STATIC_ASSERT_ENABLED 0 +# endif +#endif + +#ifndef EA_PREPROCESSOR_JOIN +# define EA_PREPROCESSOR_JOIN(a, b) EA_PREPROCESSOR_JOIN1(a, b) +# define EA_PREPROCESSOR_JOIN1(a, b) EA_PREPROCESSOR_JOIN2(a, b) +# define EA_PREPROCESSOR_JOIN2(a, b) a##b +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) + // static_assert is defined by the compiler for both C and C++. +#elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__) + // static_assert is defined by the compiler. +#elif defined(__clang__) && __has_feature(cxx_static_assert) + // static_assert is defined by the compiler. +#else +# if EABASE_STATIC_ASSERT_ENABLED +# if defined(__COUNTER__) // If this VC++ extension is available... +# define static_assert(expression, description) enum { EA_PREPROCESSOR_JOIN(static_assert_, __COUNTER__) = 1 / ((!!(expression)) ? 1 : 0) } +# else +# define static_assert(expression, description) enum { EA_PREPROCESSOR_JOIN(static_assert_, __LINE__) = 1 / ((!!(expression)) ? 1 : 0) } +# endif +# else +# if defined(EA_COMPILER_METROWERKS) +# if defined(__cplusplus) +# define static_assert(expression, description) struct EA_PREPROCESSOR_JOIN(EACTAssertUnused_, __LINE__){ } +# else +# define static_assert(expression, description) enum { EA_PREPROCESSOR_JOIN(static_assert_, __LINE__) = 1 / ((!!(expression)) ? 1 : 0) } +# endif +# else +# define static_assert(expression, description) +# endif +# endif +#endif + + +#endif // Header include guard + + + + + + + + + diff --git a/lib/eastl/include/EABase/earesult.h b/lib/eastl/include/EABase/earesult.h new file mode 100644 index 0000000..928d9fc --- /dev/null +++ b/lib/eastl/include/EABase/earesult.h @@ -0,0 +1,78 @@ +/* +Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*----------------------------------------------------------------------------- + * earesult.h + * + * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. + * Maintained by Paul Pedriana, Maxis + *---------------------------------------------------------------------------*/ + + +#ifndef INCLUDED_earesult_H +#define INCLUDED_earesult_H + + +#ifndef INCLUDED_eabase_H + #include "EABase/eabase.h" +#endif + + + +/// \brief This result type is width-compatible with most systems +typedef int32_t ea_result_type; + + +namespace EA +{ + typedef int32_t result_type; + + enum + { + SUCCESS = 0, + FAILURE = -1 + }; +} + + +/// \brief Macro to simplify testing for success +#ifndef EA_SUCCEEDED + #define EA_SUCCEEDED(result) ((result) >= 0) +#endif + +/// \brief Macro to simplfify testing for general failure +#ifndef EA_FAILED + #define EA_FAILED(result) ((result) < 0) +#endif + + +#endif + + + + diff --git a/lib/eastl/include/EASTL/algorithm.h b/lib/eastl/include/EASTL/algorithm.h new file mode 100644 index 0000000..4ce479e --- /dev/null +++ b/lib/eastl/include/EASTL/algorithm.h @@ -0,0 +1,2979 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/algorithm.h +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements some of the primary algorithms from the C++ STL +// algorithm library. These versions are just like that STL versions and so +// are redundant. They are provided solely for the purpose of projects that +// either cannot use standard C++ STL or want algorithms that have guaranteed +// identical behaviour across platforms. +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Definitions +// +// You will notice that we are very particular about the templated typenames +// we use here. You will notice that we follow the C++ standard closely in +// these respects. Each of these typenames have a specific meaning; +// this is why we don't just label templated arguments with just letters +// such as T, U, V, A, B. Here we provide a quick reference for the typenames +// we use. See the C++ standard, section 25-8 for more details. +// -------------------------------------------------------------- +// typename Meaning +// -------------------------------------------------------------- +// T The value type. +// Compare A function which takes two arguments and returns the lesser of the two. +// Predicate A function which takes one argument returns true if the argument meets some criteria. +// BinaryPredicate A function which takes two arguments and returns true if some criteria is met (e.g. they are equal). +// StrickWeakOrdering A BinaryPredicate that compares two objects, returning true if the first precedes the second. Like Compare but has additional requirements. Used for sorting routines. +// Function A function which takes one argument and applies some operation to the target. +// Size A count or size. +// Generator A function which takes no arguments and returns a value (which will usually be assigned to an object). +// UnaryOperation A function which takes one argument and returns a value (which will usually be assigned to second object). +// BinaryOperation A function which takes two arguments and returns a value (which will usually be assigned to a third object). +// InputIterator An input iterator (iterator you read from) which allows reading each element only once and only in a forward direction. +// ForwardIterator An input iterator which is like InputIterator except it can be reset back to the beginning. +// BidirectionalIterator An input iterator which is like ForwardIterator except it can be read in a backward direction as well. +// RandomAccessIterator An input iterator which can be addressed like an array. It is a superset of all other input iterators. +// OutputIterator An output iterator (iterator you write to) which allows writing each element only once in only in a forward direction. +// +// Note that with iterators that a function which takes an InputIterator will +// also work with a ForwardIterator, BidirectionalIterator, or RandomAccessIterator. +// The given iterator type is merely the -minimum- supported functionality the +// iterator must support. +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Optimizations +// +// There are a number of opportunities for opptimizations that we take here +// in this library. The most obvious kinds are those that subsitute memcpy +// in the place of a conventional loop for data types with which this is +// possible. The algorithms here are optimized to a higher level than currently +// available C++ STL algorithms from vendors. This is especially +// so for game programming on console devices, as we do things such as reduce +// branching relative to other STL algorithm implementations. However, the +// proper implementation of these algorithm optimizations is a fairly tricky +// thing. +// +// The various things we look to take advantage of in order to implement +// optimizations include: +// - Taking advantage of random access iterators. +// - Taking advantage of POD (plain old data) data types. +// - Taking advantage of type_traits in general. +// - Reducing branching and taking advantage of likely branch predictions. +// - Taking advantage of issues related to pointer and reference aliasing. +// - Improving cache coherency during memory accesses. +// - Making code more likely to be inlinable by the compiler. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ALGORITHM_H +#define EASTL_ALGORITHM_H + + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) +#endif +#include +#ifdef __MWERKS__ + #include <../Include/string.h> // Force the compiler to use the std lib header. +#else + #include // memcpy, memcmp, memmove +#endif +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// min/max workaround +// +// MSVC++ has #defines for min/max which collide with the min/max algorithm +// declarations. The following may still not completely resolve some kinds of +// problems with MSVC++ #defines, though it deals with most cases in production +// game code. +// +#if EASTL_NOMINMAX + #ifdef min + #undef min + #endif + #ifdef max + #undef max + #endif +#endif + + + + +namespace eastl +{ + #if EASTL_MINMAX_ENABLED + + /// min + /// + /// Min returns the lesser of its two arguments; it returns the first + /// argument if neither is less than the other. The two arguments are + /// compared with operator <. + /// + /// This min and our other min implementations are defined as returning: + /// b < a ? b : a + /// which for example may in practice result in something different than: + /// b <= a ? b : a + /// in the case where b is different from a (though they compare as equal). + /// We choose the specific ordering here because that's the ordering + /// done by other STL implementations. + /// + template + inline const T& + min(const T& a, const T& b) + { + return b < a ? b : a; + } + #endif // EASTL_MINMAX_ENABLED + + + /// min_alt + /// + /// This is an alternative version of min that avoids any possible + /// collisions with Microsoft #defines of min and max. + /// + /// See min(a, b) for detailed specifications. + /// + template + inline const T& + min_alt(const T& a, const T& b) + { + return b < a ? b : a; + } + + #if EASTL_MINMAX_ENABLED + /// min + /// + /// Min returns the lesser of its two arguments; it returns the first + /// argument if neither is less than the other. The two arguments are + /// compared with the Compare function (or function object), which + /// takes two arguments and returns true if the first is less than + /// the second. + /// + /// See min(a, b) for detailed specifications. + /// + /// Example usage: + /// struct A{ int a; }; + /// struct Struct{ bool operator()(const A& a1, const A& a2){ return a1.a < a2.a; } }; + /// + /// A a1, a2, a3; + /// a3 = min(a1, a2, Struct()); + /// + /// Example usage: + /// struct B{ int b; }; + /// inline bool Function(const B& b1, const B& b2){ return b1.b < b2.b; } + /// + /// B b1, b2, b3; + /// b3 = min(b1, b2, Function); + /// + template + inline const T& + min(const T& a, const T& b, Compare compare) + { + return compare(b, a) ? b : a; + } + + #endif // EASTL_MINMAX_ENABLED + + + /// min_alt + /// + /// This is an alternative version of min that avoids any possible + /// collisions with Microsoft #defines of min and max. + /// + /// See min(a, b) for detailed specifications. + /// + template + inline const T& + min_alt(const T& a, const T& b, Compare compare) + { + return compare(b, a) ? b : a; + } + + + #if EASTL_MINMAX_ENABLED + /// max + /// + /// Max returns the greater of its two arguments; it returns the first + /// argument if neither is greater than the other. The two arguments are + /// compared with operator < (and not operator >). + /// + /// This min and our other min implementations are defined as returning: + /// a < b ? b : a + /// which for example may in practice result in something different than: + /// a <= b ? b : a + /// in the case where b is different from a (though they compare as equal). + /// We choose the specific ordering here because that's the ordering + /// done by other STL implementations. + /// + template + inline const T& + max(const T& a, const T& b) + { + return a < b ? b : a; + } + #endif // EASTL_MINMAX_ENABLED + + + /// max_alt + /// + /// This is an alternative version of max that avoids any possible + /// collisions with Microsoft #defines of min and max. + /// + template + inline const T& + max_alt(const T& a, const T& b) + { + return a < b ? b : a; + } + + #if EASTL_MINMAX_ENABLED + /// max + /// + /// Min returns the lesser of its two arguments; it returns the first + /// argument if neither is less than the other. The two arguments are + /// compared with the Compare function (or function object), which + /// takes two arguments and returns true if the first is less than + /// the second. + /// + template + inline const T& + max(const T& a, const T& b, Compare compare) + { + return compare(a, b) ? b : a; + } + + #endif + + + /// max_alt + /// + /// This is an alternative version of max that avoids any possible + /// collisions with Microsoft #defines of min and max. + /// + template + inline const T& + max_alt(const T& a, const T& b, Compare compare) + { + return compare(a, b) ? b : a; + } + + + + /// min_element + /// + /// min_element finds the smallest element in the range [first, last). + /// It returns the first iterator i in [first, last) such that no other + /// iterator in [first, last) points to a value smaller than *i. + /// The return value is last if and only if [first, last) is an empty range. + /// + /// Returns: The first iterator i in the range [first, last) such that + /// for any iterator j in the range [first, last) the following corresponding + /// condition holds: !(*j < *i). + /// + /// Complexity: Exactly 'max((last - first) - 1, 0)' applications of the + /// corresponding comparisons. + /// + template + ForwardIterator min_element(ForwardIterator first, ForwardIterator last) + { + if(first != last) + { + ForwardIterator currentMin = first; + + while(++first != last) + { + if(*first < *currentMin) + currentMin = first; + } + return currentMin; + } + return first; + } + + + /// min_element + /// + /// min_element finds the smallest element in the range [first, last). + /// It returns the first iterator i in [first, last) such that no other + /// iterator in [first, last) points to a value smaller than *i. + /// The return value is last if and only if [first, last) is an empty range. + /// + /// Returns: The first iterator i in the range [first, last) such that + /// for any iterator j in the range [first, last) the following corresponding + /// conditions hold: compare(*j, *i) == false. + /// + /// Complexity: Exactly 'max((last - first) - 1, 0)' applications of the + /// corresponding comparisons. + /// + template + ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare compare) + { + if(first != last) + { + ForwardIterator currentMin = first; + + while(++first != last) + { + if(compare(*first, *currentMin)) + currentMin = first; + } + return currentMin; + } + return first; + } + + + /// max_element + /// + /// max_element finds the largest element in the range [first, last). + /// It returns the first iterator i in [first, last) such that no other + /// iterator in [first, last) points to a value greater than *i. + /// The return value is last if and only if [first, last) is an empty range. + /// + /// Returns: The first iterator i in the range [first, last) such that + /// for any iterator j in the range [first, last) the following corresponding + /// condition holds: !(*i < *j). + /// + /// Complexity: Exactly 'max((last - first) - 1, 0)' applications of the + /// corresponding comparisons. + /// + template + ForwardIterator max_element(ForwardIterator first, ForwardIterator last) + { + if(first != last) + { + ForwardIterator currentMax = first; + + while(++first != last) + { + if(*currentMax < *first) + currentMax = first; + } + return currentMax; + } + return first; + } + + + /// max_element + /// + /// max_element finds the largest element in the range [first, last). + /// It returns the first iterator i in [first, last) such that no other + /// iterator in [first, last) points to a value greater than *i. + /// The return value is last if and only if [first, last) is an empty range. + /// + /// Returns: The first iterator i in the range [first, last) such that + /// for any iterator j in the range [first, last) the following corresponding + /// condition holds: compare(*i, *j) == false. + /// + /// Complexity: Exactly 'max((last - first) - 1, 0)' applications of the + /// corresponding comparisons. + /// + template + ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare compare) + { + if(first != last) + { + ForwardIterator currentMax = first; + + while(++first != last) + { + if(compare(*currentMax, *first)) + currentMax = first; + } + return currentMax; + } + return first; + } + + + /// median + /// + /// median finds which element of three (a, b, d) is in-between the other two. + /// If two or more elements are equal, the first (e.g. a before b) is chosen. + /// + /// Complexity: Either two or three comparisons will be required, depending + /// on the values. + /// + template + inline const T& median(const T& a, const T& b, const T& c) + { + if(a < b) + { + if(b < c) + return b; + else if(a < c) + return c; + else + return a; + } + else if(a < c) + return a; + else if(b < c) + return c; + return b; + } + + + /// median + /// + /// median finds which element of three (a, b, d) is in-between the other two. + /// If two or more elements are equal, the first (e.g. a before b) is chosen. + /// + /// Complexity: Either two or three comparisons will be required, depending + /// on the values. + /// + template + inline const T& median(const T& a, const T& b, const T& c, Compare compare) + { + if(compare(a, b)) + { + if(compare(b, c)) + return b; + else if(compare(a, c)) + return c; + else + return a; + } + else if(compare(a, c)) + return a; + else if(compare(b, c)) + return c; + return b; + } + + + + /// swap + /// + /// Assigns the contents of a to b and the contents of b to a. + /// A temporary instance of type T is created and destroyed + /// in the process. + /// + /// This function is used by numerous other algorithms, and as + /// such it may in some cases be feasible and useful for the user + /// to implement an override version of this function which is + /// more efficient in some way. + /// + template + inline void swap(T& a, T& b) + { + T temp(a); + a = b; + b = temp; + } + + + + // iter_swap helper functions + // + template + struct iter_swap_impl + { + template + static void iter_swap(ForwardIterator1 a, ForwardIterator2 b) + { + typedef typename eastl::iterator_traits::value_type value_type_a; + + value_type_a temp(*a); + *a = *b; + *b = temp; + } + }; + + template <> + struct iter_swap_impl + { + template + static void iter_swap(ForwardIterator1 a, ForwardIterator2 b) + { + eastl::swap(*a, *b); + } + }; + + /// iter_swap + /// + /// Equivalent to swap(*a, *b), though the user can provide an override to + /// iter_swap that is independent of an override which may exist for swap. + /// + /// We provide a version of iter_swap which uses swap when the swapped types + /// are equal but a manual implementation otherwise. We do this because the + /// C++ standard defect report says that iter_swap(a, b) must be implemented + /// as swap(*a, *b) when possible. + /// + template + inline void iter_swap(ForwardIterator1 a, ForwardIterator2 b) + { + typedef typename eastl::iterator_traits::value_type value_type_a; + typedef typename eastl::iterator_traits::value_type value_type_b; + typedef typename eastl::iterator_traits::reference reference_a; + typedef typename eastl::iterator_traits::reference reference_b; + + iter_swap_impl::value, is_same::value, is_same::value >::value >::iter_swap(a, b); + } + + + + /// swap_ranges + /// + /// Swaps each of the elements in the range [first1, last1) with the + /// corresponding element in the range [first2, first2 + (last1 - first1)). + /// + /// Effects: For each nonnegative integer n < (last1 - first1), + /// performs: swap(*(first1 + n), *(first2 + n)). + /// + /// Requires: The two ranges [first1, last1) and [first2, first2 + (last1 - first1)) + /// shall not overlap. + /// + /// Returns: first2 + (last1 - first1). That is, returns the end of the second range. + /// + /// Complexity: Exactly 'last1 - first1' swaps. + /// + template + inline ForwardIterator2 + swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2) + { + for(; first1 != last1; ++first1, ++first2) + iter_swap(first1, first2); + return first2; + } + + + + /// adjacent_find + /// + /// Returns: The first iterator i such that both i and i + 1 are in the range + /// [first, last) for which the following corresponding conditions hold: *i == *(i + 1). + /// Returns last if no such iterator is found. + /// + /// Complexity: Exactly 'find(first, last, value) - first' applications of the corresponding predicate. + /// + template + inline ForwardIterator + adjacent_find(ForwardIterator first, ForwardIterator last) + { + if(first != last) + { + ForwardIterator i = first; + + for(++i; i != last; ++i) + { + if(*first == *i) + return first; + first = i; + } + } + return last; + } + + + + /// adjacent_find + /// + /// Returns: The first iterator i such that both i and i + 1 are in the range + /// [first, last) for which the following corresponding conditions hold: predicate(*i, *(i + 1)) != false. + /// Returns last if no such iterator is found. + /// + /// Complexity: Exactly 'find(first, last, value) - first' applications of the corresponding predicate. + /// + template + inline ForwardIterator + adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate predicate) + { + if(first != last) + { + ForwardIterator i = first; + + for(++i; i != last; ++i) + { + if(predicate(*first, *i)) + return first; + first = i; + } + } + return last; + } + + + + + // copy + // + // We implement copy via some helper functions whose purpose is to + // try to use memcpy when possible. We need to use type_traits and + // iterator categories to do this. + // + template + struct copy_impl + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + for(; first != last; ++result, ++first) + *result = *first; + return result; + } + }; + + template <> + struct copy_impl // If we have a trivally copyable random access array, use memcpy + { + template + static T* do_copy(const T* first, const T* last, T* result) + { + // We cannot use memcpy because memcpy requires the entire source and dest ranges to be + // non-overlapping, whereas the copy algorithm requires only that 'result' not be within + // the range from first to last. + return (T*)memmove(result, first, (size_t)((uintptr_t)last - (uintptr_t)first)) + (last - first); + } + }; + + // copy_chooser + // Calls one of the above copy_impl functions. + template + inline OutputIterator + copy_chooser(InputIterator first, InputIterator last, OutputIterator result) + { + typedef typename eastl::iterator_traits::iterator_category IC; + typedef typename eastl::iterator_traits::value_type value_type_input; + typedef typename eastl::iterator_traits::value_type value_type_output; + + const bool bHasTrivialCopy = type_and::value, + is_pointer::value, + is_pointer::value, + is_same::value>::value; + + return eastl::copy_impl::do_copy(first, last, result); + } + + // copy_generic_iterator + // Converts a copy call via a generic_iterator to a copy call via the iterator type the + // generic_iterator holds. We do this because generic_iterator's purpose is to hold + // iterators that are simply pointers, and if we want the functions above to be fast, + // we need them to see the pointers and not an iterator that wraps the pointers as + // does generic_iterator. We are forced into using a templated struct with a templated + // do_copy member function because C++ doesn't allow specializations for standalone functions. + template + struct copy_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return eastl::copy_chooser(first, last, result); + } + }; + + template <> + struct copy_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return eastl::copy_chooser(first.base(), last.base(), result); // first.base(), last.base() will resolve to a pointer (e.g. T*). + } + }; + + template <> + struct copy_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return OutputIterator(eastl::copy_chooser(first, last, result.base())); // Have to convert to OutputIterator because result.base() is a T* + } + }; + + template <> + struct copy_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return OutputIterator(eastl::copy_chooser(first.base(), last.base(), result.base())); // Have to convert to OutputIterator because result.base() is a T* + } + }; + + /// copy + /// + /// Effects: Copies elements in the range [first, last) into the range [result, result + (last - first)) + /// starting from first and proceeding to last. For each nonnegative integer n < (last - first), + /// performs *(result + n) = *(first + n). + /// + /// Returns: result + (last - first). That is, returns the end of the result. Note that this + /// is different from how memcpy works, as memcpy returns the beginning of the result. + /// + /// Requires: result shall not be in the range [first, last). + /// + /// Complexity: Exactly 'last - first' assignments. + /// + /// Note: This function is like memcpy in that the result must not be with the + /// range of (first, last), as would cause memory to be overwritten incorrectly. + /// + template + inline OutputIterator + copy(InputIterator first, InputIterator last, OutputIterator result) + { + //#ifdef __GNUC__ // GCC has template depth problems and this shortcut may need to be enabled. + // return eastl::copy_chooser(first, last, result); + //#else + const bool bInputIsGenericIterator = is_generic_iterator::value; + const bool bOutputIsGenericIterator = is_generic_iterator::value; + return eastl::copy_generic_iterator::do_copy(first, last, result); + //#endif + } + + + + + // copy_backward + // + // We implement copy_backward via some helper functions whose purpose is + // to try to use memcpy when possible. We need to use type_traits and + // iterator categories to do this. + // + template + struct copy_backward_impl + { + template + static BidirectionalIterator2 do_copy(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result) + { + while(last != first) + *--result = *--last; + return result; + } + }; + + template <> + struct copy_backward_impl // If we have a trivally copyable random access array, use memcpy + { + template + static T* do_copy(const T* first, const T* last, T* result) + { + return (T*)memmove(result - (last - first), first, (size_t)((uintptr_t)last - (uintptr_t)first)); + } + }; + + // copy_backward_chooser + // Calls one of the above copy_backward_impl functions. + template + inline OutputIterator + copy_backward_chooser(InputIterator first, InputIterator last, OutputIterator result) + { + typedef typename eastl::iterator_traits::iterator_category IC; + typedef typename eastl::iterator_traits::value_type value_type_input; + typedef typename eastl::iterator_traits::value_type value_type_output; + + const bool bHasTrivialCopy = type_and::value, + is_pointer::value, + is_pointer::value, + is_same::value>::value; + + return eastl::copy_backward_impl::do_copy(first, last, result); + } + + // copy_backward_generic_iterator + // Converts a copy call via a generic_iterator to a copy call via the iterator type the + // generic_iterator holds. We do this because generic_iterator's purpose is to hold + // iterators that are simply pointers, and if we want the functions above to be fast, + // we need them to see the pointers and not an iterator that wraps the pointers as + // does generic_iterator. We are forced into using a templated struct with a templated + // do_copy member function because C++ doesn't allow specializations for standalone functions. + template + struct copy_backward_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return eastl::copy_backward_chooser(first, last, result); + } + }; + + template <> + struct copy_backward_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return eastl::copy_backward_chooser(first.base(), last.base(), result); // first.base(), last.base() will resolve to a pointer (e.g. T*). + } + }; + + template <> + struct copy_backward_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return OutputIterator(eastl::copy_backward_chooser(first, last, result.base())); // Have to convert to OutputIterator because result.base() is a T* + } + }; + + template <> + struct copy_backward_generic_iterator + { + template + static OutputIterator do_copy(InputIterator first, InputIterator last, OutputIterator result) + { + return OutputIterator(eastl::copy_backward_chooser(first.base(), last.base(), result.base())); // Have to convert to OutputIterator because result.base() is a T* + } + }; + + /// copy_backward + /// + /// copies memory in the range of [first, last) to the range *ending* with result. + /// + /// Effects: Copies elements in the range [first, last) into the range + /// [result - (last - first), result) starting from last 1 and proceeding to first. + /// For each positive integer n <= (last - first), performs *(result n) = *(last - n). + /// + /// Requires: result shall not be in the range [first, last). + /// + /// Returns: result - (last - first). That is, returns the beginning of the result range. + /// + /// Complexity: Exactly 'last - first' assignments. + /// + template + inline BidirectionalIterator2 + copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result) + { + const bool bInputIsGenericIterator = is_generic_iterator::value; + const bool bOutputIsGenericIterator = is_generic_iterator::value; + + return eastl::copy_backward_generic_iterator::do_copy(first, last, result); + } + + + + /// count + /// + /// Counts the number of items in the range of [first, last) which equal the input value. + /// + /// Effects: Returns the number of iterators i in the range [first, last) for which the + /// following corresponding conditions hold: *i == value. + /// + /// Complexity: At most 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of count is count_if and not another variation of count. + /// This is because both versions would have three parameters and there could be ambiguity. + /// + template + inline typename eastl::iterator_traits::difference_type + count(InputIterator first, InputIterator last, const T& value) + { + typename eastl::iterator_traits::difference_type result = 0; + + for(; first != last; ++first) + { + if(*first == value) + ++result; + } + return result; + } + + + /// count_if + /// + /// Counts the number of items in the range of [first, last) which match + /// the input value as defined by the input predicate function. + /// + /// Effects: Returns the number of iterators i in the range [first, last) for which the + /// following corresponding conditions hold: predicate(*i) != false. + /// + /// Complexity: At most 'last - first' applications of the corresponding predicate. + /// + /// Note: The non-predicate version of count_if is count and not another variation of count_if. + /// This is because both versions would have three parameters and there could be ambiguity. + /// + template + inline typename eastl::iterator_traits::difference_type + count_if(InputIterator first, InputIterator last, Predicate predicate) + { + typename eastl::iterator_traits::difference_type result = 0; + + for(; first != last; ++first) + { + if(predicate(*first)) + ++result; + } + return result; + } + + + + // fill + // + // We implement some fill helper functions in order to allow us to optimize it + // where possible. + // + template + struct fill_imp + { + template + static void do_fill(ForwardIterator first, ForwardIterator last, const T& value) + { + // The C++ standard doesn't specify whether we need to create a temporary + // or not, but all std STL implementations are written like what we have here. + for(; first != last; ++first) + *first = value; + } + }; + + template <> + struct fill_imp + { + template + static void do_fill(ForwardIterator first, ForwardIterator last, const T& value) + { + // We create a temp and fill from that because value might alias to the + // destination range and so the compiler would be forced into generating + // less efficient code. + for(const T temp(value); first != last; ++first) + *first = temp; + } + }; + + /// fill + /// + /// fill is like memset in that it assigns a single value repeatedly to a + /// destination range. It allows for any type of iterator (not just an array) + /// and the source value can be any type, not just a byte. + /// Note that the source value (which is a reference) can come from within + /// the destination range. + /// + /// Effects: Assigns value through all the iterators in the range [first, last). + /// + /// Complexity: Exactly 'last - first' assignments. + /// + /// Note: The C++ standard doesn't specify anything about the value parameter + /// coming from within the first-last range. All std STL implementations act + /// as if the standard specifies that value must not come from within this range. + /// + template + inline void fill(ForwardIterator first, ForwardIterator last, const T& value) + { + eastl::fill_imp< is_scalar::value >::do_fill(first, last, value); + + // Possibly better implementation, as it will deal with small PODs as well as scalars: + // bEasyCopy is true if the type has a trivial constructor (e.g. is a POD) and if + // it is small. Thus any built-in type or any small user-defined struct will qualify. + //const bool bEasyCopy = eastl::type_and::value, + // eastl::integral_constant::value; + //eastl::fill_imp::do_fill(first, last, value); + + } + + inline void fill(char* first, char* last, const char& c) // It's debateable whether we should use 'char& c' or 'char c' here. + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + inline void fill(char* first, char* last, const int c) // This is used for cases like 'fill(first, last, 0)'. + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + inline void fill(unsigned char* first, unsigned char* last, const unsigned char& c) + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + inline void fill(unsigned char* first, unsigned char* last, const int c) + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + inline void fill(signed char* first, signed char* last, const signed char& c) + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + inline void fill(signed char* first, signed char* last, const int c) + { + memset(first, (unsigned char)c, (size_t)(last - first)); + } + + #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__SNC__) || defined(__ICL) || defined(__PPU__) || defined(__SPU__) // SN = SN compiler, ICL = Intel compiler, PPU == PS3 processor, SPU = PS3 cell processor + inline void fill(bool* first, bool* last, const bool& b) + { + memset(first, (char)b, (size_t)(last - first)); + } + #endif + + + + + // fill_n + // + // We implement some fill helper functions in order to allow us to optimize it + // where possible. + // + template + struct fill_n_imp + { + template + static OutputIterator do_fill(OutputIterator first, Size n, const T& value) + { + for(; n-- > 0; ++first) + *first = value; + return first; + } + }; + + template <> + struct fill_n_imp + { + template + static OutputIterator do_fill(OutputIterator first, Size n, const T& value) + { + // We create a temp and fill from that because value might alias to + // the destination range and so the compiler would be forced into + // generating less efficient code. + for(const T temp = value; n-- > 0; ++first) + *first = temp; + return first; + } + }; + + /// fill_n + /// + /// The fill_n function is very much like memset in that a copies a source value + /// n times into a destination range. The source value may come from within + /// the destination range. + /// + /// Effects: Assigns value through all the iterators in the range [first, first + n). + /// + /// Complexity: Exactly n assignments. + /// + template + OutputIterator fill_n(OutputIterator first, Size n, const T& value) + { + #ifdef _MSC_VER // VC++ up to and including VC8 blow up when you pass a 64 bit scalar to the do_fill function. + return eastl::fill_n_imp< is_scalar::value && (sizeof(T) <= sizeof(uint32_t)) >::do_fill(first, n, value); + #else + return eastl::fill_n_imp< is_scalar::value >::do_fill(first, n, value); + #endif + } + + template + inline char* fill_n(char* first, Size n, const char& c) + { + return (char*)memset(first, (char)c, (size_t)n) + n; + } + + template + inline unsigned char* fill_n(unsigned char* first, Size n, const unsigned char& c) + { + return (unsigned char*)memset(first, (unsigned char)c, (size_t)n) + n; + } + + template + inline signed char* fill_n(signed char* first, Size n, const signed char& c) + { + return (signed char*)memset(first, (signed char)c, n) + (size_t)n; + } + + #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__SNC__) || defined(__ICL) || defined(__PPU__) || defined(__SPU__) // SN = SN compiler, ICL = Intel compiler, PU == PS3 processor, SPU = PS3 cell processor + template + inline bool* fill_n(bool* first, Size n, const bool& b) + { + return (bool*)memset(first, (char)b, n) + (size_t)n; + } + #endif + + + + /// find + /// + /// finds the value within the unsorted range of [first, last). + /// + /// Returns: The first iterator i in the range [first, last) for which + /// the following corresponding conditions hold: *i == value. + /// Returns last if no such iterator is found. + /// + /// Complexity: At most 'last - first' applications of the corresponding predicate. + /// This is a linear search and not a binary one. + /// + /// Note: The predicate version of find is find_if and not another variation of find. + /// This is because both versions would have three parameters and there could be ambiguity. + /// + template + inline InputIterator + find(InputIterator first, InputIterator last, const T& value) + { + while((first != last) && !(*first == value)) // Note that we always express value comparisons in terms of < or ==. + ++first; + return first; + } + + + + /// find_if + /// + /// finds the value within the unsorted range of [first, last). + /// + /// Returns: The first iterator i in the range [first, last) for which + /// the following corresponding conditions hold: pred(*i) != false. + /// Returns last if no such iterator is found. + /// If the sequence of elements to search for (i.e. first2 - last2) is empty, + /// the find always fails and last1 will be returned. + /// + /// Complexity: At most 'last - first' applications of the corresponding predicate. + /// + /// Note: The non-predicate version of find_if is find and not another variation of find_if. + /// This is because both versions would have three parameters and there could be ambiguity. + /// + template + inline InputIterator + find_if(InputIterator first, InputIterator last, Predicate predicate) + { + while((first != last) && !predicate(*first)) + ++first; + return first; + } + + + + /// find_first_of + /// + /// find_first_of is similar to find in that it performs linear search through + /// a range of ForwardIterators. The difference is that while find searches + /// for one particular value, find_first_of searches for any of several values. + /// Specifically, find_first_of searches for the first occurrance in the + /// range [first1, last1) of any of the elements in [first2, last2). + /// This function is thus similar to the strpbrk standard C string function. + /// If the sequence of elements to search for (i.e. first2-last2) is empty, + /// the find always fails and last1 will be returned. + /// + /// Effects: Finds an element that matches one of a set of values. + /// + /// Returns: The first iterator i in the range [first1, last1) such that for some + /// integer j in the range [first2, last2) the following conditions hold: *i == *j. + /// Returns last1 if no such iterator is found. + /// + /// Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the + /// corresponding predicate. + /// + template + ForwardIterator1 + find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + for(; first1 != last1; ++first1) + { + for(ForwardIterator2 i = first2; i != last2; ++i) + { + if(*first1 == *i) + return first1; + } + } + return last1; + } + + + /// find_first_of + /// + /// find_first_of is similar to find in that it performs linear search through + /// a range of ForwardIterators. The difference is that while find searches + /// for one particular value, find_first_of searches for any of several values. + /// Specifically, find_first_of searches for the first occurrance in the + /// range [first1, last1) of any of the elements in [first2, last2). + /// This function is thus similar to the strpbrk standard C string function. + /// + /// Effects: Finds an element that matches one of a set of values. + /// + /// Returns: The first iterator i in the range [first1, last1) such that for some + /// integer j in the range [first2, last2) the following conditions hold: pred(*i, *j) != false. + /// Returns last1 if no such iterator is found. + /// + /// Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the + /// corresponding predicate. + /// + template + ForwardIterator1 + find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + for(; first1 != last1; ++first1) + { + for(ForwardIterator2 i = first2; i != last2; ++i) + { + if(predicate(*first1, *i)) + return first1; + } + } + return last1; + } + + + /// find_first_not_of + /// + /// Searches through first range for the first element that does not belong the second input range. + /// This is very much like the C++ string find_first_not_of function. + /// + /// Returns: The first iterator i in the range [first1, last1) such that for some + /// integer j in the range [first2, last2) the following conditions hold: !(*i == *j). + /// Returns last1 if no such iterator is found. + /// + /// Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the + /// corresponding predicate. + /// + template + ForwardIterator1 + find_first_not_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + for(; first1 != last1; ++first1) + { + if(eastl::find(first2, last2, *first1) == last2) + break; + } + + return first1; + } + + + + /// find_first_not_of + /// + /// Searches through first range for the first element that does not belong the second input range. + /// This is very much like the C++ string find_first_not_of function. + /// + /// Returns: The first iterator i in the range [first1, last1) such that for some + /// integer j in the range [first2, last2) the following conditions hold: pred(*i, *j) == false. + /// Returns last1 if no such iterator is found. + /// + /// Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the + /// corresponding predicate. + /// + template + inline ForwardIterator1 + find_first_not_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + typedef typename eastl::iterator_traits::value_type value_type; + + for(; first1 != last1; ++first1) + { + if(eastl::find_if(first2, last2, eastl::bind1st(predicate, *first1)) == last2) + break; + } + + return first1; + } + + + template + inline BidirectionalIterator1 + find_last_of(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + if((first1 != last1) && (first2 != last2)) + { + BidirectionalIterator1 it1(last1); + + while((--it1 != first1) && (eastl::find(first2, last2, *it1) == last2)) + ; // Do nothing + + if((it1 != first1) || (eastl::find(first2, last2, *it1) != last2)) + return it1; + } + + return last1; + } + + + template + BidirectionalIterator1 + find_last_of(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + typedef typename eastl::iterator_traits::value_type value_type; + + if((first1 != last1) && (first2 != last2)) + { + BidirectionalIterator1 it1(last1); + + while((--it1 != first1) && (eastl::find_if(first2, last2, eastl::bind1st(predicate, *it1)) == last2)) + ; // Do nothing + + if((it1 != first1) || (eastl::find_if(first2, last2, eastl::bind1st(predicate, *it1)) != last2)) + return it1; + } + + return last1; + } + + + template + inline BidirectionalIterator1 + find_last_not_of(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + if((first1 != last1) && (first2 != last2)) + { + BidirectionalIterator1 it1(last1); + + while((--it1 != first1) && (eastl::find(first2, last2, *it1) != last2)) + ; // Do nothing + + if((it1 != first1) || (eastl::find( first2, last2, *it1) == last2)) + return it1; + } + + return last1; + } + + + template + inline BidirectionalIterator1 + find_last_not_of(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + typedef typename eastl::iterator_traits::value_type value_type; + + if((first1 != last1) && (first2 != last2)) + { + BidirectionalIterator1 it1(last1); + + while((--it1 != first1) && (eastl::find_if(first2, last2, eastl::bind1st(predicate, *it1)) != last2)) + ; // Do nothing + + if((it1 != first1) || (eastl::find_if(first2, last2, eastl::bind1st(predicate, *it1))) != last2) + return it1; + } + + return last1; + } + + + + + /// for_each + /// + /// Calls the Function function for each value in the range [first, last). + /// Function takes a single parameter: the current value. + /// + /// Effects: Applies function to the result of dereferencing every iterator in + /// the range [first, last), starting from first and proceeding to last 1. + /// + /// Returns: function. + /// + /// Complexity: Applies function exactly 'last - first' times. + /// + /// Note: If function returns a result, the result is ignored. + /// + template + inline Function + for_each(InputIterator first, InputIterator last, Function function) + { + for(; first != last; ++first) + function(*first); + return function; + } + + + /// generate + /// + /// Iterates the range of [first, last) and assigns to each element the + /// result of the function generator. Generator is a function which takes + /// no arguments. + /// + /// Complexity: Exactly 'last - first' invocations of generator and assignments. + /// + template + inline void + generate(ForwardIterator first, ForwardIterator last, Generator generator) + { + for(; first != last; ++first) // We cannot call generate_n(first, last-first, generator) + *first = generator(); // because the 'last-first' might not be supported by the + } // given iterator. + + + /// generate_n + /// + /// Iterates an interator n times and assigns the result of generator + /// to each succeeding element. Generator is a function which takes + /// no arguments. + /// + /// Complexity: Exactly n invocations of generator and assignments. + /// + template + inline OutputIterator + generate_n(OutputIterator first, Size n, Generator generator) + { + for(; n > 0; --n, ++first) + *first = generator(); + return first; + } + + + /// transform + /// + /// Iterates the input range of [first, last) and the output iterator result + /// and assigns the result of unaryOperation(input) to result. + /// + /// Effects: Assigns through every iterator i in the range [result, result + (last1 - first1)) + /// a new corresponding value equal to unaryOperation(*(first1 + (i - result)). + /// + /// Requires: op shall not have any side effects. + /// + /// Returns: result + (last1 - first1). That is, returns the end of the output range. + /// + /// Complexity: Exactly 'last1 - first1' applications of unaryOperation. + /// + /// Note: result may be equal to first. + /// + template + inline OutputIterator + transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unaryOperation) + { + for(; first != last; ++first, ++result) + *result = unaryOperation(*first); + return result; + } + + + /// transform + /// + /// Iterates the input range of [first, last) and the output iterator result + /// and assigns the result of binaryOperation(input1, input2) to result. + /// + /// Effects: Assigns through every iterator i in the range [result, result + (last1 - first1)) + /// a new corresponding value equal to binaryOperation(*(first1 + (i - result), *(first2 + (i - result))). + /// + /// Requires: binaryOperation shall not have any side effects. + /// + /// Returns: result + (last1 - first1). That is, returns the end of the output range. + /// + /// Complexity: Exactly 'last1 - first1' applications of binaryOperation. + /// + /// Note: result may be equal to first1 or first2. + /// + template + inline OutputIterator + transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binaryOperation) + { + for(; first1 != last1; ++first1, ++first2, ++result) + *result = binaryOperation(*first1, *first2); + return result; + } + + + /// equal + /// + /// Returns: true if for every iterator i in the range [first1, last1) the + /// following corresponding conditions hold: predicate(*i, *(first2 + (i - first1))) != false. + /// Otherwise, returns false. + /// + /// Complexity: At most last1 first1 applications of the corresponding predicate. + /// + /// To consider: Make specializations of this for scalar types and random access + /// iterators that uses memcmp or some trick memory comparison function. + /// We should verify that such a thing results in an improvement. + /// + template + inline bool + equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2) + { + for(; first1 != last1; ++first1, ++first2) + { + if(!(*first1 == *first2)) // Note that we always express value comparisons in terms of < or ==. + return false; + } + return true; + } + + /// equal + /// + /// Returns: true if for every iterator i in the range [first1, last1) the + /// following corresponding conditions hold: pred(*i, *(first2 + (i first1))) != false. + /// Otherwise, returns false. + /// + /// Complexity: At most last1 first1 applications of the corresponding predicate. + /// + template + inline bool + equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate predicate) + { + for(; first1 != last1; ++first1, ++first2) + { + if(!predicate(*first1, *first2)) + return false; + } + return true; + } + + + + /// identical + /// + /// Returns true if the two input ranges are equivalent. + /// There is a subtle difference between this algorithm and + /// the 'equal' algorithm. The equal algorithm assumes the + /// two ranges are of equal length. This algorithm efficiently + /// compares two ranges for both length equality and for + /// element equality. There is no other standard algorithm + /// that can do this. + /// + /// Returns: true if the sequence of elements defined by the range + /// [first1, last1) is of the same length as the sequence of + /// elements defined by the range of [first2, last2) and if + /// the elements in these ranges are equal as per the + /// equal algorithm. + /// + /// Complexity: At most 'min((last1 - first1), (last2 - first2))' applications + /// of the corresponding comparison. + /// + template + bool identical(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2) + { + while((first1 != last1) && (first2 != last2) && (*first1 == *first2)) + { + ++first1; + ++first2; + } + return (first1 == last1) && (first2 == last2); + } + + + /// identical + /// + template + bool identical(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, BinaryPredicate predicate) + { + while((first1 != last1) && (first2 != last2) && predicate(*first1, *first2)) + { + ++first1; + ++first2; + } + return (first1 == last1) && (first2 == last2); + } + + + /// lexicographical_compare + /// + /// Returns: true if the sequence of elements defined by the range + /// [first1, last1) is lexicographically less than the sequence of + /// elements defined by the range [first2, last2). Returns false otherwise. + /// + /// Complexity: At most 'min((last1 - first1), (last2 - first2))' applications + /// of the corresponding comparison. + /// + /// Note: If two sequences have the same number of elements and their + /// corresponding elements are equivalent, then neither sequence is + /// lexicographically less than the other. If one sequence is a prefix + /// of the other, then the shorter sequence is lexicographically less + /// than the longer sequence. Otherwise, the lexicographical comparison + /// of the sequences yields the same result as the comparison of the first + /// corresponding pair of elements that are not equivalent. + /// + template + inline bool + lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2) + { + for(; (first1 != last1) && (first2 != last2); ++first1, ++first2) + { + if(*first1 < *first2) + return true; + if(*first2 < *first1) + return false; + } + return (first1 == last1) && (first2 != last2); + } + + inline bool // Specialization for const char*. + lexicographical_compare(const char* first1, const char* last1, const char* first2, const char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + inline bool // Specialization for char*. + lexicographical_compare(char* first1, char* last1, char* first2, char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + inline bool // Specialization for const unsigned char*. + lexicographical_compare(const unsigned char* first1, const unsigned char* last1, const unsigned char* first2, const unsigned char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + inline bool // Specialization for unsigned char*. + lexicographical_compare(unsigned char* first1, unsigned char* last1, unsigned char* first2, unsigned char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + inline bool // Specialization for const signed char*. + lexicographical_compare(const signed char* first1, const signed char* last1, const signed char* first2, const signed char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + inline bool // Specialization for signed char*. + lexicographical_compare(signed char* first1, signed char* last1, signed char* first2, signed char* last2) + { + const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + return result ? (result < 0) : (n1 < n2); + } + + #if defined(_MSC_VER) // If using the VC++ compiler (and thus bool is known to be a single byte)... + //Not sure if this is a good idea. + //inline bool // Specialization for const bool*. + //lexicographical_compare(const bool* first1, const bool* last1, const bool* first2, const bool* last2) + //{ + // const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + // const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + // return result ? (result < 0) : (n1 < n2); + //} + // + //inline bool // Specialization for bool*. + //lexicographical_compare(bool* first1, bool* last1, bool* first2, bool* last2) + //{ + // const ptrdiff_t n1(last1 - first1), n2(last2 - first2); + // const int result = memcmp(first1, first2, (size_t)eastl::min_alt(n1, n2)); + // return result ? (result < 0) : (n1 < n2); + //} + #endif + + + + /// lexicographical_compare + /// + /// Returns: true if the sequence of elements defined by the range + /// [first1, last1) is lexicographically less than the sequence of + /// elements defined by the range [first2, last2). Returns false otherwise. + /// + /// Complexity: At most 'min((last1 -first1), (last2 - first2))' applications + /// of the corresponding comparison. + /// + /// Note: If two sequences have the same number of elements and their + /// corresponding elements are equivalent, then neither sequence is + /// lexicographically less than the other. If one sequence is a prefix + /// of the other, then the shorter sequence is lexicographically less + /// than the longer sequence. Otherwise, the lexicographical comparison + /// of the sequences yields the same result as the comparison of the first + /// corresponding pair of elements that are not equivalent. + /// + /// Note: False is always returned if range 1 is exhausted before range 2. + /// The result of this is that you can't do a successful reverse compare + /// (e.g. use greater<> as the comparison instead of less<>) unless the + /// two sequences are of identical length. What you want to do is reverse + /// the order of the arguments in order to get the desired effect. + /// + template + inline bool + lexicographical_compare(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, Compare compare) + { + for(; (first1 != last1) && (first2 != last2); ++first1, ++first2) + { + if(compare(*first1, *first2)) + return true; + if(compare(*first2, *first1)) + return false; + } + return (first1 == last1) && (first2 != last2); + } + + + + /// lower_bound + /// + /// Finds the position of the first element in a sorted range that has a value + /// greater than or equivalent to a specified value. + /// + /// Effects: Finds the first position into which value can be inserted without + /// violating the ordering. + /// + /// Returns: The furthermost iterator i in the range [first, last) such that + /// for any iterator j in the range [first, i) the following corresponding + /// condition holds: *j < value. + /// + /// Complexity: At most 'log(last - first) + 1' comparisons. + /// + /// Optimizations: We have no need to specialize this implementation for random + /// access iterators (e.g. contiguous array), as the code below will already + /// take advantage of them. + /// + template + ForwardIterator + lower_bound(ForwardIterator first, ForwardIterator last, const T& value) + { + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType d = eastl::distance(first, last); // This will be efficient for a random access iterator such as an array. + + while(d > 0) + { + ForwardIterator i = first; + DifferenceType d2 = d >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, d2); // This will be efficient for a random access iterator such as an array. + + if(*i < value) + { + // Disabled because std::lower_bound doesn't specify (23.3.3.3, p3) this can be done: EASTL_VALIDATE_COMPARE(!(value < *i)); // Validate that the compare function is sane. + first = ++i; + d -= d2 + 1; + } + else + d = d2; + } + return first; + } + + + /// lower_bound + /// + /// Finds the position of the first element in a sorted range that has a value + /// greater than or equivalent to a specified value. The input Compare function + /// takes two arguments and returns true if the first argument is less than + /// the second argument. + /// + /// Effects: Finds the first position into which value can be inserted without + /// violating the ordering. + /// + /// Returns: The furthermost iterator i in the range [first, last) such that + /// for any iterator j in the range [first, i) the following corresponding + /// condition holds: compare(*j, value) != false. + /// + /// Complexity: At most 'log(last - first) + 1' comparisons. + /// + /// Optimizations: We have no need to specialize this implementation for random + /// access iterators (e.g. contiguous array), as the code below will already + /// take advantage of them. + /// + template + ForwardIterator + lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType d = eastl::distance(first, last); // This will be efficient for a random access iterator such as an array. + + while(d > 0) + { + ForwardIterator i = first; + DifferenceType d2 = d >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, d2); // This will be efficient for a random access iterator such as an array. + + if(compare(*i, value)) + { + // Disabled because std::lower_bound doesn't specify (23.3.3.1, p3) this can be done: EASTL_VALIDATE_COMPARE(!compare(value, *i)); // Validate that the compare function is sane. + first = ++i; + d -= d2 + 1; + } + else + d = d2; + } + return first; + } + + + + /// upper_bound + /// + /// Finds the position of the first element in a sorted range that has a + /// value that is greater than a specified value. + /// + /// Effects: Finds the furthermost position into which value can be inserted + /// without violating the ordering. + /// + /// Returns: The furthermost iterator i in the range [first, last) such that + /// for any iterator j in the range [first, i) the following corresponding + /// condition holds: !(value < *j). + /// + /// Complexity: At most 'log(last - first) + 1' comparisons. + /// + template + ForwardIterator + upper_bound(ForwardIterator first, ForwardIterator last, const T& value) + { + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType len = eastl::distance(first, last); + + while(len > 0) + { + ForwardIterator i = first; + DifferenceType len2 = len >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, len2); + + if(!(value < *i)) // Note that we always express value comparisons in terms of < or ==. + { + first = ++i; + len -= len2 + 1; + } + else + { + // Disabled because std::upper_bound doesn't specify (23.3.3.2, p3) this can be done: EASTL_VALIDATE_COMPARE(!(*i < value)); // Validate that the compare function is sane. + len = len2; + } + } + return first; + } + + + /// upper_bound + /// + /// Finds the position of the first element in a sorted range that has a + /// value that is greater than a specified value. The input Compare function + /// takes two arguments and returns true if the first argument is less than + /// the second argument. + /// + /// Effects: Finds the furthermost position into which value can be inserted + /// without violating the ordering. + /// + /// Returns: The furthermost iterator i in the range [first, last) such that + /// for any iterator j in the range [first, i) the following corresponding + /// condition holds: compare(value, *j) == false. + /// + /// Complexity: At most 'log(last - first) + 1' comparisons. + /// + template + ForwardIterator + upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType len = eastl::distance(first, last); + + while(len > 0) + { + ForwardIterator i = first; + DifferenceType len2 = len >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, len2); + + if(!compare(value, *i)) + { + first = ++i; + len -= len2 + 1; + } + else + { + // Disabled because std::upper_bound doesn't specify (23.3.3.2, p3) this can be done: EASTL_VALIDATE_COMPARE(!compare(*i, value)); // Validate that the compare function is sane. + len = len2; + } + } + return first; + } + + + /// equal_range + /// + /// Effects: Finds the largest subrange [i, j) such that the value can be inserted + /// at any iterator k in it without violating the ordering. k satisfies the + /// corresponding conditions: !(*k < value) && !(value < *k). + /// + /// Complexity: At most '2 * log(last - first) + 1' comparisons. + /// + template + pair + equal_range(ForwardIterator first, ForwardIterator last, const T& value) + { + typedef pair ResultType; + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType d = eastl::distance(first, last); + + while(d > 0) + { + ForwardIterator i(first); + DifferenceType d2 = d >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, d2); + + if(*i < value) + { + EASTL_VALIDATE_COMPARE(!(value < *i)); // Validate that the compare function is sane. + first = ++i; + d -= d2 + 1; + } + else if(value < *i) + { + EASTL_VALIDATE_COMPARE(!(*i < value)); // Validate that the compare function is sane. + d = d2; + last = i; + } + else + { + ForwardIterator j(i); + + return ResultType(eastl::lower_bound(first, i, value), + eastl::upper_bound(++j, last, value)); + } + } + return ResultType(first, first); + } + + + /// equal_range + /// + /// Effects: Finds the largest subrange [i, j) such that the value can be inserted + /// at any iterator k in it without violating the ordering. k satisfies the + /// corresponding conditions: comp(*k, value) == false && comp(value, *k) == false. + /// + /// Complexity: At most '2 * log(last - first) + 1' comparisons. + /// + template + pair + equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare compare) + { + typedef pair ResultType; + typedef typename eastl::iterator_traits::difference_type DifferenceType; + + DifferenceType d = eastl::distance(first, last); + + while(d > 0) + { + ForwardIterator i(first); + DifferenceType d2 = d >> 1; // We use '>>1' here instead of '/2' because MSVC++ for some reason generates significantly worse code for '/2'. Go figure. + + eastl::advance(i, d2); + + if(compare(*i, value)) + { + EASTL_VALIDATE_COMPARE(!compare(value, *i)); // Validate that the compare function is sane. + first = ++i; + d -= d2 + 1; + } + else if(compare(value, *i)) + { + EASTL_VALIDATE_COMPARE(!compare(*i, value)); // Validate that the compare function is sane. + d = d2; + last = i; + } + else + { + ForwardIterator j(i); + + return ResultType(eastl::lower_bound(first, i, value, compare), + eastl::upper_bound(++j, last, value, compare)); + } + } + return ResultType(first, first); + } + + + /// replace + /// + /// Effects: Substitutes elements referred by the iterator i in the range [first, last) + /// with new_value, when the following corresponding conditions hold: *i == old_value. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of replace is replace_if and not another variation of replace. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + template + inline void + replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value) + { + for(; first != last; ++first) + { + if(*first == old_value) + *first = new_value; + } + } + + + /// replace_if + /// + /// Effects: Substitutes elements referred by the iterator i in the range [first, last) + /// with new_value, when the following corresponding conditions hold: predicate(*i) != false. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of replace_if is replace and not another variation of replace_if. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + template + inline void + replace_if(ForwardIterator first, ForwardIterator last, Predicate predicate, const T& new_value) + { + for(; first != last; ++first) + { + if(predicate(*first)) + *first = new_value; + } + } + + + /// remove_copy + /// + /// Effects: Copies all the elements referred to by the iterator i in the range + /// [first, last) for which the following corresponding condition does not hold: + /// *i == value. + /// + /// Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap. + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + template + inline OutputIterator + remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value) + { + for(; first != last; ++first) + { + if(!(*first == value)) // Note that we always express value comparisons in terms of < or ==. + { + *result = *first; + ++result; + } + } + return result; + } + + + /// remove_copy_if + /// + /// Effects: Copies all the elements referred to by the iterator i in the range + /// [first, last) for which the following corresponding condition does not hold: + /// predicate(*i) != false. + /// + /// Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap. + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + template + inline OutputIterator + remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate predicate) + { + for(; first != last; ++first) + { + if(!predicate(*first)) + { + *result = *first; + ++result; + } + } + return result; + } + + + /// remove + /// + /// Effects: Eliminates all the elements referred to by iterator i in the + /// range [first, last) for which the following corresponding condition + /// holds: *i == value. + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of remove is remove_if and not another variation of remove. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + /// Note: Since this function moves the element to the back of the heap and + /// doesn't actually remove it from the given container, the user must call + /// the container erase function if the user wants to erase the element + /// from the container. + /// + /// Example usage: + /// vector intArray; + /// ... + /// intArray.erase(remove(intArray.begin(), intArray.end(), 4), intArray.end()); // Erase all elements of value 4. + /// + template + inline ForwardIterator + remove(ForwardIterator first, ForwardIterator last, const T& value) + { + first = eastl::find(first, last, value); + if(first != last) + { + ForwardIterator i(first); + return eastl::remove_copy(++i, last, first, value); + } + return first; + } + + + /// remove_if + /// + /// Effects: Eliminates all the elements referred to by iterator i in the + /// range [first, last) for which the following corresponding condition + /// holds: predicate(*i) != false. + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of remove_if is remove and not another variation of remove_if. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + /// Note: Since this function moves the element to the back of the heap and + /// doesn't actually remove it from the given container, the user must call + /// the container erase function if the user wants to erase the element + /// from the container. + /// + /// Example usage: + /// vector intArray; + /// ... + /// intArray.erase(remove(intArray.begin(), intArray.end(), bind2nd(less(), (int)3)), intArray.end()); // Erase all elements less than 3. + /// + template + inline ForwardIterator + remove_if(ForwardIterator first, ForwardIterator last, Predicate predicate) + { + first = eastl::find_if(first, last, predicate); + if(first != last) + { + ForwardIterator i(first); + return eastl::remove_copy_if(++i, last, first, predicate); + } + return first; + } + + + /// replace_copy + /// + /// Effects: Assigns to every iterator i in the range [result, result + (last - first)) + /// either new_value or *(first + (i - result)) depending on whether the following + /// corresponding conditions hold: *(first + (i - result)) == old_value. + /// + /// Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap. + /// + /// Returns: result + (last - first). + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of replace_copy is replace_copy_if and not another variation of replace_copy. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + template + inline OutputIterator + replace_copy(InputIterator first, InputIterator last, OutputIterator result, const T& old_value, const T& new_value) + { + for(; first != last; ++first, ++result) + *result = (*first == old_value) ? new_value : *first; + return result; + } + + + /// replace_copy_if + /// + /// Effects: Assigns to every iterator i in the range [result, result + (last - first)) + /// either new_value or *(first + (i - result)) depending on whether the following + /// corresponding conditions hold: predicate(*(first + (i - result))) != false. + /// + /// Requires: The ranges [first, last) and [result, result+(lastfirst)) shall not overlap. + /// + /// Returns: result + (last - first). + /// + /// Complexity: Exactly 'last - first' applications of the corresponding predicate. + /// + /// Note: The predicate version of replace_copy_if is replace_copy and not another variation of replace_copy_if. + /// This is because both versions would have the same parameter count and there could be ambiguity. + /// + template + inline OutputIterator + replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate predicate, const T& new_value) + { + for(; first != last; ++first, ++result) + *result = predicate(*first) ? new_value : *first; + return result; + } + + + + + // reverse + // + // We provide helper functions which allow reverse to be implemented more + // efficiently for some types of iterators and types. + // + template + inline void reverse_impl(BidirectionalIterator first, BidirectionalIterator last, EASTL_ITC_NS::bidirectional_iterator_tag) + { + for(; (first != last) && (first != --last); ++first) // We are not allowed to use operator <, <=, >, >= with a + eastl::iter_swap(first, last); // generic (bidirectional or otherwise) iterator. + } + + template + inline void reverse_impl(RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag) + { + for(; first < --last; ++first) // With a random access iterator, we can use operator < to more efficiently implement + eastl::iter_swap(first, last); // this algorithm. A generic iterator doesn't necessarily have an operator < defined. + } + + /// reverse + /// + /// Reverses the values within the range [first, last). + /// + /// Effects: For each nonnegative integer i <= (last - first) / 2, + /// applies swap to all pairs of iterators first + i, (last i) - 1. + /// + /// Complexity: Exactly '(last - first) / 2' swaps. + /// + template + inline void reverse(BidirectionalIterator first, BidirectionalIterator last) + { + typedef typename eastl::iterator_traits::iterator_category IC; + eastl::reverse_impl(first, last, IC()); + } + + + + /// reverse_copy + /// + /// Copies the range [first, last) in reverse order to the result. + /// + /// Effects: Copies the range [first, last) to the range + /// [result, result + (last - first)) such that for any nonnegative + /// integer i < (last - first) the following assignment takes place: + /// *(result + (last - first) - i) = *(first + i) + /// + /// Requires: The ranges [first, last) and [result, result + (last - first)) + /// shall not overlap. + /// + /// Returns: result + (last - first). That is, returns the end of the output range. + /// + /// Complexity: Exactly 'last - first' assignments. + /// + template + inline OutputIterator + reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result) + { + for(; first != last; ++result) + *result = *--last; + return result; + } + + + + /// search + /// + /// Search finds a subsequence within the range [first1, last1) that is identical to [first2, last2) + /// when compared element-by-element. It returns an iterator pointing to the beginning of that + /// subsequence, or else last1 if no such subsequence exists. As such, it is very much like + /// the C strstr function, with the primary difference being that strstr uses 0-terminated strings + /// whereas search uses an end iterator to specify the end of a string. + /// + /// Returns: The first iterator i in the range [first1, last1 - (last2 - first2)) such that for + /// any nonnegative integer n less than 'last2 - first2' the following corresponding condition holds: + /// *(i + n) == *(first2 + n). Returns last1 if no such iterator is found. + /// + /// Complexity: At most (last1 first1) * (last2 first2) applications of the corresponding predicate. + /// + template + ForwardIterator1 + search(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + if(first2 != last2) // If there is anything to search for... + { + // We need to make a special case for a pattern of one element, + // as the logic below prevents one element patterns from working. + ForwardIterator2 temp2(first2); + ++temp2; + + if(temp2 != last2) // If what we are searching for has a length > 1... + { + ForwardIterator1 cur1(first1); + ForwardIterator2 p2; + + while(first1 != last1) + { + // The following loop is the equivalent of eastl::find(first1, last1, *first2) + while((first1 != last1) && !(*first1 == *first2)) + ++first1; + + if(first1 != last1) + { + p2 = temp2; + cur1 = first1; + + if(++cur1 != last1) + { + while(*cur1 == *p2) + { + if(++p2 == last2) + return first1; + + if(++cur1 == last1) + return last1; + } + + ++first1; + continue; + } + } + return last1; + } + + // Fall through to the end. + } + else + return eastl::find(first1, last1, *first2); + } + + return first1; + + + #if 0 + /* Another implementation which is a little more simpler but executes a little slower on average. + typedef typename eastl::iterator_traits::difference_type difference_type_1; + typedef typename eastl::iterator_traits::difference_type difference_type_2; + + const difference_type_2 d2 = eastl::distance(first2, last2); + + for(difference_type_1 d1 = eastl::distance(first1, last1); d1 >= d2; ++first1, --d1) + { + ForwardIterator1 temp1 = first1; + + for(ForwardIterator2 temp2 = first2; ; ++temp1, ++temp2) + { + if(temp2 == last2) + return first1; + if(!(*temp1 == *temp2)) + break; + } + } + + return last1; + */ + #endif + } + + + /// search + /// + /// Search finds a subsequence within the range [first1, last1) that is identical to [first2, last2) + /// when compared element-by-element. It returns an iterator pointing to the beginning of that + /// subsequence, or else last1 if no such subsequence exists. As such, it is very much like + /// the C strstr function, with the only difference being that strstr uses 0-terminated strings + /// whereas search uses an end iterator to specify the end of a string. + /// + /// Returns: The first iterator i in the range [first1, last1 - (last2 - first2)) such that for + /// any nonnegative integer n less than 'last2 - first2' the following corresponding condition holds: + /// predicate(*(i + n), *(first2 + n)) != false. Returns last1 if no such iterator is found. + /// + /// Complexity: At most (last1 first1) * (last2 first2) applications of the corresponding predicate. + /// + template + ForwardIterator1 + search(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + typedef typename eastl::iterator_traits::difference_type difference_type_1; + typedef typename eastl::iterator_traits::difference_type difference_type_2; + + difference_type_2 d2 = eastl::distance(first2, last2); + + if(d2 != 0) + { + ForwardIterator1 i(first1); + eastl::advance(i, d2); + + for(difference_type_1 d1 = eastl::distance(first1, last1); d1 >= d2; --d1) + { + if(eastl::equal(first1, i, first2, predicate)) + return first1; + if(d1 > d2) // To do: Find a way to make the algorithm more elegant. + { + ++first1; + ++i; + } + } + return last1; + } + return first1; // Just like with strstr, we return first1 if the match string is empty. + } + + + + // search_n helper functions + // + template + ForwardIterator // Generic implementation. + search_n_impl(ForwardIterator first, ForwardIterator last, Size count, const T& value, EASTL_ITC_NS::forward_iterator_tag) + { + if(count <= 0) + return first; + + Size d1 = (Size)eastl::distance(first, last); // Should d1 be of type Size, ptrdiff_t, or iterator_traits::difference_type? + // The problem with using iterator_traits::difference_type is that + if(count > d1) // ForwardIterator may not be a true iterator but instead something like a pointer. + return last; + + for(; d1 >= count; ++first, --d1) + { + ForwardIterator i(first); + + for(Size n = 0; n < count; ++n, ++i, --d1) + { + if(!(*i == value)) // Note that we always express value comparisons in terms of < or ==. + goto not_found; + } + return first; + + not_found: + first = i; + } + return last; + } + + template inline + RandomAccessIterator // Random access iterator implementation. Much faster than generic implementation. + search_n_impl(RandomAccessIterator first, RandomAccessIterator last, Size count, const T& value, EASTL_ITC_NS::random_access_iterator_tag) + { + if(count <= 0) + return first; + else if(count == 1) + return find(first, last, value); + else if(last > first) + { + RandomAccessIterator lookAhead; + RandomAccessIterator backTrack; + + Size skipOffset = (count - 1); + Size tailSize = (Size)(last - first); + Size remainder; + Size prevRemainder; + + for(lookAhead = first + skipOffset; tailSize >= count; lookAhead += count) + { + tailSize -= count; + + if(*lookAhead == value) + { + remainder = skipOffset; + + for(backTrack = lookAhead - 1; *backTrack == value; --backTrack) + { + if(--remainder == 0) + return (lookAhead - skipOffset); // success + } + + if(remainder <= tailSize) + { + prevRemainder = remainder; + + while(*(++lookAhead) == value) + { + if(--remainder == 0) + return (backTrack + 1); // success + } + tailSize -= (prevRemainder - remainder); + } + else + return last; // failure + } + + // lookAhead here is always pointing to the element of the last mismatch. + } + } + + return last; // failure + } + + + /// search_n + /// + /// Returns: The first iterator i in the range [first, last count) such that + /// for any nonnegative integer n less than count the following corresponding + /// conditions hold: *(i + n) == value, pred(*(i + n),value) != false. + /// Returns last if no such iterator is found. + /// + /// Complexity: At most '(last1 - first1) * count' applications of the corresponding predicate. + /// + template + ForwardIterator + search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value) + { + typedef typename eastl::iterator_traits::iterator_category IC; + return eastl::search_n_impl(first, last, count, value, IC()); + } + + + /// binary_search + /// + /// Returns: true if there is an iterator i in the range [first last) that + /// satisfies the corresponding conditions: !(*i < value) && !(value < *i). + /// + /// Complexity: At most 'log(last - first) + 2' comparisons. + /// + /// Note: The reason binary_search returns bool instead of an iterator is + /// that search_n, lower_bound, or equal_range already return an iterator. + /// However, there are arguments that binary_search should return an iterator. + /// Note that we provide binary_search_i (STL extension) to return an iterator. + /// + /// To use search_n to find an item, do this: + /// iterator i = search_n(begin, end, 1, value); + /// To use lower_bound to find an item, do this: + /// iterator i = lower_bound(begin, end, value); + /// if((i != last) && !(value < *i)) + /// + /// It turns out that the above lower_bound method is as fast as binary_search + /// would be if it returned an iterator. + /// + template + inline bool + binary_search(ForwardIterator first, ForwardIterator last, const T& value) + { + // To do: This can be made slightly faster by not using lower_bound. + ForwardIterator i(eastl::lower_bound(first, last, value)); + return ((i != last) && !(value < *i)); // Note that we always express value comparisons in terms of < or ==. + } + + + /// binary_search + /// + /// Returns: true if there is an iterator i in the range [first last) that + /// satisfies the corresponding conditions: compare(*i, value) == false && + /// compare(value, *i) == false. + /// + /// Complexity: At most 'log(last - first) + 2' comparisons. + /// + /// Note: See comments above regarding the bool return value of binary_search. + /// + template + inline bool + binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare compare) + { + // To do: This can be made slightly faster by not using lower_bound. + ForwardIterator i(eastl::lower_bound(first, last, value, compare)); + return ((i != last) && !compare(value, *i)); + } + + + /// binary_search_i + /// + /// Returns: iterator if there is an iterator i in the range [first last) that + /// satisfies the corresponding conditions: !(*i < value) && !(value < *i). + /// Returns last if the value is not found. + /// + /// Complexity: At most 'log(last - first) + 2' comparisons. + /// + template + inline ForwardIterator + binary_search_i(ForwardIterator first, ForwardIterator last, const T& value) + { + // To do: This can be made slightly faster by not using lower_bound. + ForwardIterator i(eastl::lower_bound(first, last, value)); + if((i != last) && !(value < *i)) // Note that we always express value comparisons in terms of < or ==. + return i; + return last; + } + + + /// binary_search_i + /// + /// Returns: iterator if there is an iterator i in the range [first last) that + /// satisfies the corresponding conditions: !(*i < value) && !(value < *i). + /// Returns last if the value is not found. + /// + /// Complexity: At most 'log(last - first) + 2' comparisons. + /// + template + inline ForwardIterator + binary_search_i(ForwardIterator first, ForwardIterator last, const T& value, Compare compare) + { + // To do: This can be made slightly faster by not using lower_bound. + ForwardIterator i(eastl::lower_bound(first, last, value, compare)); + if((i != last) && !compare(value, *i)) + return i; + return last; + } + + + /// unique + /// + /// Given a sorted range, this function removes duplicated items. + /// Note that if you have a container then you will probably want + /// to call erase on the container with the return value if your + /// goal is to remove the duplicated items from the container. + /// + /// Effects: Eliminates all but the first element from every consecutive + /// group of equal elements referred to by the iterator i in the range + /// [first, last) for which the following corresponding condition holds: + /// *i == *(i - 1). + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: If the range (last - first) is not empty, exactly (last - first) + /// applications of the corresponding predicate, otherwise no applications of the predicate. + /// + /// Example usage: + /// vector intArray; + /// ... + /// intArray.erase(unique(intArray.begin(), intArray.end()), intArray.end()); + /// + template + ForwardIterator unique(ForwardIterator first, ForwardIterator last) + { + first = eastl::adjacent_find(first, last); + + if(first != last) // We expect that there are duplicated items, else the user wouldn't be calling this function. + { + ForwardIterator dest(first); + + for(++first; first != last; ++first) + { + if(!(*dest == *first)) // Note that we always express value comparisons in terms of < or ==. + *++dest = *first; + } + return ++dest; + } + return last; + } + + + /// unique + /// + /// Given a sorted range, this function removes duplicated items. + /// Note that if you have a container then you will probably want + /// to call erase on the container with the return value if your + /// goal is to remove the duplicated items from the container. + /// + /// Effects: Eliminates all but the first element from every consecutive + /// group of equal elements referred to by the iterator i in the range + /// [first, last) for which the following corresponding condition holds: + /// predicate(*i, *(i - 1)) != false. + /// + /// Returns: The end of the resulting range. + /// + /// Complexity: If the range (last - first) is not empty, exactly (last - first) + /// applications of the corresponding predicate, otherwise no applications of the predicate. + /// + template + ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate predicate) + { + first = eastl::adjacent_find(first, last, predicate); + + if(first != last) // We expect that there are duplicated items, else the user wouldn't be calling this function. + { + ForwardIterator dest(first); + + for(++first; first != last; ++first) + { + if(!predicate(*dest, *first)) + *++dest = *first; + } + return ++dest; + } + return last; + } + + + + // find_end + // + // We provide two versions here, one for a bidirectional iterators and one for + // regular forward iterators. Given that we are searching backward, it's a bit + // more efficient if we can use backwards iteration to implement our search, + // though this requires an iterator that can be reversed. + // + template + ForwardIterator1 + find_end_impl(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + EASTL_ITC_NS::forward_iterator_tag, EASTL_ITC_NS::forward_iterator_tag) + { + if(first2 != last2) // We have to do this check because the search algorithm below will return first1 (and not last1) if the first2/last2 range is empty. + { + for(ForwardIterator1 result(last1); ; ) + { + const ForwardIterator1 resultNext(eastl::search(first1, last1, first2, last2)); + + if(resultNext != last1) // If another sequence was found... + { + first1 = result = resultNext; + ++first1; + } + else + return result; + } + } + return last1; + } + + template + BidirectionalIterator1 + find_end_impl(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + BidirectionalIterator2 first2, BidirectionalIterator2 last2, + EASTL_ITC_NS::bidirectional_iterator_tag, EASTL_ITC_NS::bidirectional_iterator_tag) + { + typedef eastl::reverse_iterator reverse_iterator1; + typedef eastl::reverse_iterator reverse_iterator2; + + reverse_iterator1 rresult(eastl::search(reverse_iterator1(last1), reverse_iterator1(first1), + reverse_iterator2(last2), reverse_iterator2(first2))); + if(rresult.base() != first1) // If we found something... + { + BidirectionalIterator1 result(rresult.base()); + + eastl::advance(result, -eastl::distance(first2, last2)); // We have an opportunity to optimize this, as the + return result; // search function already calculates this distance. + } + return last1; + } + + /// find_end + /// + /// Finds the last occurrence of the second sequence in the first sequence. + /// As such, this function is much like the C string function strrstr and it + /// is also the same as a reversed version of 'search'. It is called find_end + /// instead of the possibly more consistent search_end simply because the C++ + /// standard algorithms have such naming. + /// + /// Returns an iterator between first1 and last1 if the sequence is found. + /// returns last1 (the end of the first seqence) if the sequence is not found. + /// + template + inline ForwardIterator1 + find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) + { + typedef typename eastl::iterator_traits::iterator_category IC1; + typedef typename eastl::iterator_traits::iterator_category IC2; + + return eastl::find_end_impl(first1, last1, first2, last2, IC1(), IC2()); + } + + + + + // To consider: Fold the predicate and non-predicate versions of + // this algorithm into a single function. + template + ForwardIterator1 + find_end_impl(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate, + EASTL_ITC_NS::forward_iterator_tag, EASTL_ITC_NS::forward_iterator_tag) + { + if(first2 != last2) // We have to do this check because the search algorithm below will return first1 (and not last1) if the first2/last2 range is empty. + { + for(ForwardIterator1 result = last1; ; ) + { + const ForwardIterator1 resultNext(eastl::search(first1, last1, first2, last2, predicate)); + + if(resultNext != last1) // If another sequence was found... + { + first1 = result = resultNext; + ++first1; + } + else + return result; + } + } + return last1; + } + + template + BidirectionalIterator1 + find_end_impl(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + BidirectionalIterator2 first2, BidirectionalIterator2 last2, + BinaryPredicate predicate, + EASTL_ITC_NS::bidirectional_iterator_tag, EASTL_ITC_NS::bidirectional_iterator_tag) + { + typedef eastl::reverse_iterator reverse_iterator1; + typedef eastl::reverse_iterator reverse_iterator2; + + reverse_iterator1 rresult(eastl::search + (reverse_iterator1(last1), reverse_iterator1(first1), + reverse_iterator2(last2), reverse_iterator2(first2), + predicate)); + if(rresult.base() != first1) // If we found something... + { + BidirectionalIterator1 result(rresult.base()); + eastl::advance(result, -eastl::distance(first2, last2)); + return result; + } + return last1; + } + + + /// find_end + /// + /// Effects: Finds a subsequence of equal values in a sequence. + /// + /// Returns: The last iterator i in the range [first1, last1 - (last2 - first2)) + /// such that for any nonnegative integer n < (last2 - first2), the following + /// corresponding conditions hold: pred(*(i+n),*(first2+n)) != false. Returns + /// last1 if no such iterator is found. + /// + /// Complexity: At most (last2 - first2) * (last1 - first1 - (last2 - first2) + 1) + /// applications of the corresponding predicate. + /// + template + inline ForwardIterator1 + find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate predicate) + { + typedef typename eastl::iterator_traits::iterator_category IC1; + typedef typename eastl::iterator_traits::iterator_category IC2; + + return eastl::find_end_impl + (first1, last1, first2, last2, predicate, IC1(), IC2()); + } + + + + /// set_difference + /// + /// set_difference iterates over both input ranges and copies elements present + /// in the first range but not the second to the output range. + /// + /// Effects: Copies the elements of the range [first1, last1) which are not + /// present in the range [first2, last2) to the range beginning at result. + /// The elements in the constructed range are sorted. + /// + /// Requires: The input ranges must be sorted. + /// Requires: The output range shall not overlap with either of the original ranges. + /// + /// Returns: The end of the output range. + /// + /// Complexity: At most (2 * ((last1 - first1) + (last2 - first2)) - 1) comparisons. + /// + template + OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result) + { + while((first1 != last1) && (first2 != last2)) + { + if(*first1 < *first2) + { + *result = *first1; + ++first1; + ++result; + } + else if(*first2 < *first1) + ++first2; + else + { + ++first1; + ++first2; + } + } + + return eastl::copy(first1, last1, result); + } + + + template + OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare compare) + { + while((first1 != last1) && (first2 != last2)) + { + if(compare(*first1, *first2)) + { + EASTL_VALIDATE_COMPARE(!compare(*first2, *first1)); // Validate that the compare function is sane. + *result = *first1; + ++first1; + ++result; + } + else if(compare(*first2, *first1)) + { + EASTL_VALIDATE_COMPARE(!compare(*first1, *first2)); // Validate that the compare function is sane. + ++first2; + } + else + { + ++first1; + ++first2; + } + } + + return eastl::copy(first1, last1, result); + } + +} // namespace eastl + + + +#endif // Header include guard + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/allocator.h b/lib/eastl/include/EASTL/allocator.h new file mode 100644 index 0000000..dcbbba9 --- /dev/null +++ b/lib/eastl/include/EASTL/allocator.h @@ -0,0 +1,344 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/allocator.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_ALLOCATOR_H +#define EASTL_ALLOCATOR_H + + +#include +#include + + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4189) // local variable is initialized but not referenced +#endif + + +namespace eastl +{ + + /// EASTL_ALLOCATOR_DEFAULT_NAME + /// + /// Defines a default allocator name in the absence of a user-provided name. + /// +#ifndef EASTL_ALLOCATOR_DEFAULT_NAME +# define EASTL_ALLOCATOR_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX // Unless the user overrides something, this is "EASTL". +#endif + + + /// alloc_flags + /// + /// Defines allocation flags. + /// + enum alloc_flags + { + MEM_TEMP = 0, // Low memory, not necessarily actually temporary. + MEM_PERM = 1 // High memory, for things that won't be unloaded. + }; + + + /// allocator + /// + /// In this allocator class, note that it is not templated on any type and + /// instead it simply allocates blocks of memory much like the C malloc and + /// free functions. It can be thought of as similar to C++ std::allocator. + /// The flags parameter has meaning that is specific to the allocation + /// + class EASTL_API allocator + { + public: + typedef eastl_size_t size_type; + + EASTL_ALLOCATOR_EXPLICIT allocator(const char* pName = EASTL_NAME_VAL(EASTL_ALLOCATOR_DEFAULT_NAME)); + allocator(const allocator& x); + allocator(const allocator& x, const char* pName); + + allocator& operator=(const allocator& x); + + void* allocate(size_t n, int flags = 0); + void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0); + void deallocate(void* p, size_t n); + + const char* get_name() const; + void set_name(const char* pName); + + protected: +#if EASTL_NAME_ENABLED + const char* mpName; // Debug name, used to track memory. +#endif + }; + + bool operator==(const allocator& a, const allocator& b); + bool operator!=(const allocator& a, const allocator& b); + + EASTL_API allocator* GetDefaultAllocator(); + EASTL_API allocator* SetDefaultAllocator(allocator* pAllocator); + + + + /// get_default_allocator + /// + /// This templated function allows the user to implement a default allocator + /// retrieval function that any part of EASTL can use. EASTL containers take + /// an Allocator parameter which identifies an Allocator class to use. But + /// different kinds of allocators have different mechanisms for retrieving + /// a default allocator instance, and some don't even intrinsically support + /// such functionality. The user can override this get_default_allocator + /// function in order to provide the glue between EASTL and whatever their + /// system's default allocator happens to be. + /// + /// Example usage: + /// MyAllocatorType* gpSystemAllocator; + /// + /// MyAllocatorType* get_default_allocator(const MyAllocatorType*) + /// { return gpSystemAllocator; } + /// + template + inline Allocator* get_default_allocator(const Allocator*) + { + return NULL; // By default we return NULL; the user must make specialization of this function in order to provide their own implementation. + } + + inline EASTLAllocatorType* get_default_allocator(const EASTLAllocatorType*) + { + return EASTLAllocatorDefault(); // For the built-in allocator EASTLAllocatorType, we happen to already have a function for returning the default allocator instance, so we provide it. + } + + + /// default_allocfreemethod + /// + /// Implements a default allocfreemethod which uses the default global allocator. + /// This version supports only default alignment. + /// + inline void* default_allocfreemethod(size_t n, void* pBuffer, void* /*pContext*/) + { + EASTLAllocatorType* const pAllocator = EASTLAllocatorDefault(); + + if(pBuffer) // If freeing... + { + EASTLFree(*pAllocator, pBuffer, n); + return NULL; // The return value is meaningless for the free. + } + else // allocating + return EASTLAlloc(*pAllocator, n); + } + + + /// allocate_memory + /// + /// This is a memory allocation dispatching function. + /// To do: Make aligned and unaligned specializations. + /// Note that to do this we will need to use a class with a static + /// function instead of a standalone function like below. + /// + template + void* allocate_memory(Allocator& a, size_t n, size_t alignment, size_t alignmentOffset) + { + if(alignment <= 8) + return EASTLAlloc(a, n); + return EASTLAllocAligned(a, n, alignment, alignmentOffset); + } + +} // namespace eastl + + + + + +#ifndef EASTL_USER_DEFINED_ALLOCATOR // If the user hasn't declared that he has defined a different allocator implementation elsewhere... + +# ifdef _MSC_VER +# pragma warning(push, 0) +# include +# pragma warning(pop) +# else +# include +# endif + +# if !EASTL_DLL // If building a regular library and not building EASTL as a DLL... + // It is expected that the application define the following + // versions of operator new for the application. Either that or the + // user needs to override the implementation of the allocator class. + void* operator new[](size_t size, const char* pName, int flags, unsigned debugFlags, const char* file, int line); + void* operator new[](size_t size, size_t alignment, size_t alignmentOffset, const char* pName, int flags, unsigned debugFlags, const char* file, int line); +# endif + + namespace eastl + { + inline allocator::allocator(const char* EASTL_NAME(pName)) + { +# if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; +# endif + } + + + inline allocator::allocator(const allocator& EASTL_NAME(alloc)) + { +# if EASTL_NAME_ENABLED + mpName = alloc.mpName; +# endif + } + + + inline allocator::allocator(const allocator&, const char* EASTL_NAME(pName)) + { +# if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; +# endif + } + + + inline allocator& allocator::operator=(const allocator& EASTL_NAME(alloc)) + { +# if EASTL_NAME_ENABLED + mpName = alloc.mpName; +# endif + return *this; + } + + + inline const char* allocator::get_name() const + { +# if EASTL_NAME_ENABLED + return mpName; +# else + return EASTL_ALLOCATOR_DEFAULT_NAME; +# endif + } + + + inline void allocator::set_name(const char* EASTL_NAME(pName)) + { +# if EASTL_NAME_ENABLED + mpName = pName; +# endif + } + + + inline void* allocator::allocate(size_t n, int flags) + { +# if EASTL_NAME_ENABLED +# define pName mpName +# else +# define pName EASTL_ALLOCATOR_DEFAULT_NAME +# endif + +# if EASTL_DLL + // We currently have no support for implementing flags when + // using the C runtime library operator new function. The user + // can use SetDefaultAllocator to override the default allocator. + (void)flags; + return ::new char[n]; +# elif (EASTL_DEBUGPARAMS_LEVEL <= 0) + return ::new((char*)0, flags, 0, (char*)0, 0) char[n]; +# elif (EASTL_DEBUGPARAMS_LEVEL == 1) + return ::new( pName, flags, 0, (char*)0, 0) char[n]; +# else + return ::new( pName, flags, 0, __FILE__, __LINE__) char[n]; +# endif + } + + + inline void* allocator::allocate(size_t n, size_t alignment, size_t offset, int flags) + { +# if EASTL_DLL + // We have a problem here. We cannot support alignment, as we don't have access + // to a memory allocator that can provide aligned memory. The C++ standard doesn't + // recognize such a thing. The user will need to call SetDefaultAllocator to + // provide an alloator which supports alignment. + EASTL_ASSERT(alignment <= 8); // 8 (sizeof(double)) is the standard alignment returned by operator new. + (void)alignment; (void)offset; (void)flags; + return new char[n]; +# elif (EASTL_DEBUGPARAMS_LEVEL <= 0) + return ::new(alignment, offset, (char*)0, flags, 0, (char*)0, 0) char[n]; +# elif (EASTL_DEBUGPARAMS_LEVEL == 1) + return ::new(alignment, offset, pName, flags, 0, (char*)0, 0) char[n]; +# else + return ::new(alignment, offset, pName, flags, 0, __FILE__, __LINE__) char[n]; +# endif + +# undef pName // See above for the definition of this. + } + + + inline void allocator::deallocate(void* p, size_t) + { + delete[] (char*)p; + } + + + inline bool operator==(const allocator&, const allocator&) + { + return true; // All allocators are considered equal, as they merely use global new/delete. + } + + + inline bool operator!=(const allocator&, const allocator&) + { + return false; // All allocators are considered equal, as they merely use global new/delete. + } + + + } // namespace eastl + + +#endif // EASTL_USER_DEFINED_ALLOCATOR + + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/bitset.h b/lib/eastl/include/EASTL/bitset.h new file mode 100644 index 0000000..f099325 --- /dev/null +++ b/lib/eastl/include/EASTL/bitset.h @@ -0,0 +1,1777 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/bitset.h +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a bitset much like the C++ std::bitset class. +// The primary distinctions between this list and std::bitset are: +// - bitset is more efficient than some other std::bitset implementations, +// - bitset is savvy to an environment that doesn't have exception handling, +// as is sometimes the case with console or embedded environments. +// - bitset is savvy to environments in which 'unsigned long' is not the +// most efficient integral data type. std::bitset implementations use +// unsigned long, even if it is an inefficient integer type. +// - bitset removes as much function calls as practical, in order to allow +// debug builds to run closer in speed and code footprint to release builds. +// - bitset doesn't support string functionality. We can add this if +// it is deemed useful. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_BITSET_H +#define EASTL_BITSET_H + + +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) +#endif +#include +#ifdef __MWERKS__ + #include <../Include/string.h> // Force the compiler to use the std lib header. +#else + #include +#endif +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +#if EASTL_EXCEPTIONS_ENABLED + #ifdef _MSC_VER + #pragma warning(push, 0) + #endif + #include // std::out_of_range, std::length_error. + #ifdef _MSC_VER + #pragma warning(pop) + #endif +#endif + +#if defined(_MSC_VER) + #pragma warning(push) + #pragma warning(disable: 4127) // Conditional expression is constant +#elif defined(__SNC__) + #pragma control %push diag + #pragma diag_suppress=187 // Pointless comparison of unsigned integer with zero +#endif + + +namespace eastl +{ + + /// BitsetWordType + /// + /// Defines the integral data type used by bitset. + /// The C++ standard specifies that the std::bitset word type be unsigned long, + /// but that isn't necessarily the most efficient data type for the given platform. + /// We can follow the standard and be potentially less efficient or we can do what + /// is more efficient but less like the C++ std::bitset. + /// + #if(EA_PLATFORM_WORD_SIZE == 4) + typedef uint32_t BitsetWordType; + const uint32_t kBitsPerWord = 32; + const uint32_t kBitsPerWordMask = 31; + const uint32_t kBitsPerWordShift = 5; + #else + typedef uint64_t BitsetWordType; + const uint32_t kBitsPerWord = 64; + const uint32_t kBitsPerWordMask = 63; + const uint32_t kBitsPerWordShift = 6; + #endif + + + + /// BITSET_WORD_COUNT + /// + /// Defines the number of words we use, based on the number of bits. + /// + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x can't handle the simpler declaration below. + #define BITSET_WORD_COUNT(nBitCount) (N == 0 ? 1 : ((N - 1) / (8 * sizeof(BitsetWordType)) + 1)) + #else + #define BITSET_WORD_COUNT(nBitCount) ((N - 1) / (8 * sizeof(BitsetWordType)) + 1) + #endif + + + + /// BitsetBase + /// + /// This is a default implementation that works for any number of words. + /// + template // Templated on the number of words used to hold the bitset. + struct BitsetBase + { + typedef BitsetWordType word_type; + typedef BitsetBase this_type; + #if EASTL_BITSET_SIZE_T + typedef size_t size_type; + #else + typedef eastl_size_t size_type; + #endif + + public: + word_type mWord[NW]; + + public: + BitsetBase(); + BitsetBase(uint32_t value); + + void operator&=(const this_type& x); + void operator|=(const this_type& x); + void operator^=(const this_type& x); + + void operator<<=(size_type n); + void operator>>=(size_type n); + + void flip(); + void set(); + void set(size_type i, bool value); + void reset(); + + bool operator==(const this_type& x) const; + + bool any() const; + size_type count() const; + + unsigned long to_ulong() const; + + word_type& DoGetWord(size_type i); + word_type DoGetWord(size_type i) const; + + size_type DoFindFirst() const; + size_type DoFindNext(size_type last_find) const; + + size_type DoFindLast() const; + size_type DoFindPrev(size_type last_find) const; + + }; // class BitsetBase + + + + /// BitsetBase<1> + /// + /// This is a specialization for a bitset that fits within one word. + /// + template <> + struct BitsetBase<1> + { + typedef BitsetWordType word_type; + typedef BitsetBase<1> this_type; + #if EASTL_BITSET_SIZE_T + typedef size_t size_type; + #else + typedef eastl_size_t size_type; + #endif + + public: + word_type mWord[1]; // Defined as an array of 1 so that bitset can treat this BitsetBase like others. + + public: + BitsetBase(); + BitsetBase(uint32_t value); + + void operator&=(const this_type& x); + void operator|=(const this_type& x); + void operator^=(const this_type& x); + + void operator<<=(size_type n); + void operator>>=(size_type n); + + void flip(); + void set(); + void set(size_type i, bool value); + void reset(); + + bool operator==(const this_type& x) const; + + bool any() const; + size_type count() const; + + unsigned long to_ulong() const; + + word_type& DoGetWord(size_type); + word_type DoGetWord(size_type) const; + + size_type DoFindFirst() const; + size_type DoFindNext(size_type last_find) const; + + size_type DoFindLast() const; + size_type DoFindPrev(size_type last_find) const; + + }; // BitsetBase<1> + + + + /// BitsetBase<2> + /// + /// This is a specialization for a bitset that fits within two words. + /// The difference here is that we avoid branching (ifs and loops). + /// + template <> + struct BitsetBase<2> + { + typedef BitsetWordType word_type; + typedef BitsetBase<2> this_type; + #if EASTL_BITSET_SIZE_T + typedef size_t size_type; + #else + typedef eastl_size_t size_type; + #endif + + public: + word_type mWord[2]; + + public: + BitsetBase(); + BitsetBase(uint32_t value); + + void operator&=(const this_type& x); + void operator|=(const this_type& x); + void operator^=(const this_type& x); + + void operator<<=(size_type n); + void operator>>=(size_type n); + + void flip(); + void set(); + void set(size_type i, bool value); + void reset(); + + bool operator==(const this_type& x) const; + + bool any() const; + size_type count() const; + + unsigned long to_ulong() const; + + word_type& DoGetWord(size_type); + word_type DoGetWord(size_type) const; + + size_type DoFindFirst() const; + size_type DoFindNext(size_type last_find) const; + + size_type DoFindLast() const; + size_type DoFindPrev(size_type last_find) const; + + }; // BitsetBase<2> + + + + + /// bitset + /// + /// Implements a bitset much like the C++ std::bitset. + /// + /// As of this writing we don't have an implementation of bitset<0>, + /// as it is deemed an academic exercise that nobody should actually + /// use and it would increase code space. + /// + /// Note: bitset shifts of a magnitude >= sizeof(BitsetWordType) + /// (e.g. shift of 32 on a 32 bit system) are not guaranteed to work + /// properly. This is because some systems (e.g. Intel x86) take the + /// shift value and mod it to the word size and thus a shift of 32 + /// can become a shift of 0 on a 32 bit system. We don't attempt to + /// resolve this behaviour in this class because doing so would lead + /// to a less efficient implementation and the vast majority of the + /// time the user doesn't do shifts of >= word size. You can work + /// around this by implementing a shift of 32 as two shifts of 16. + /// + template + class bitset : private BitsetBase + { + public: + typedef BitsetBase base_type; + typedef bitset this_type; + typedef BitsetWordType word_type; + typedef typename base_type::size_type size_type; + + enum + { + kSize = N, + kWordCount = BITSET_WORD_COUNT(N), + kNW = kWordCount // This name is deprecated. + }; + + using base_type::mWord; + using base_type::DoGetWord; + using base_type::DoFindFirst; + using base_type::DoFindNext; + using base_type::DoFindLast; + using base_type::DoFindPrev; + + public: + /// reference + /// + /// A reference is a reference to a specific bit in the bitset. + /// The C++ standard specifies that this be a nested class, + /// though it is not clear if a non-nested reference implementation + /// would be non-conforming. + /// + class reference + { + protected: + friend class bitset; + + word_type* mpBitWord; + size_type mnBitIndex; + + reference(){} // The C++ standard specifies that this is private. + + public: + reference(const bitset& x, size_type i); + + reference& operator=(bool value); + reference& operator=(const reference& x); + + bool operator~() const; + operator bool() const // Defined inline because CodeWarrior fails to be able to compile it outside. + { return (*mpBitWord & (static_cast(1) << (mnBitIndex & kBitsPerWordMask))) != 0; } + + reference& flip(); + }; + + public: + friend class reference; + + bitset(); + bitset(uint32_t value); + + // We don't define copy constructor and operator= because + // the compiler-generated versions will suffice. + + this_type& operator&=(const this_type& x); + this_type& operator|=(const this_type& x); + this_type& operator^=(const this_type& x); + + this_type& operator<<=(size_type n); + this_type& operator>>=(size_type n); + + this_type& set(); + this_type& set(size_type i, bool value = true); + + this_type& reset(); + this_type& reset(size_type i); + + this_type& flip(); + this_type& flip(size_type i); + this_type operator~() const; + + reference operator[](size_type i); + bool operator[](size_type i) const; + + const word_type* data() const; + word_type* data(); + + unsigned long to_ulong() const; + + size_type count() const; + size_type size() const; + + bool operator==(const this_type& x) const; + bool operator!=(const this_type& x) const; + + bool test(size_type i) const; + bool any() const; + bool none() const; + + this_type operator<<(size_type n) const; + this_type operator>>(size_type n) const; + + // Finds the index of the first "on" bit, returns kSize if none are set. + size_type find_first() const; + + // Finds the index of the next "on" bit after last_find, returns kSize if none are set. + size_type find_next(size_type last_find) const; + + // Finds the index of the last "on" bit, returns kSize if none are set. + size_type find_last() const; + + // Finds the index of the last "on" bit before last_find, returns kSize if none are set. + size_type find_prev(size_type last_find) const; + + }; // bitset + + + + + + + + /// BitsetCountBits + /// + /// This is a fast trick way to count bits without branches nor memory accesses. + /// + #if(EA_PLATFORM_WORD_SIZE == 4) + inline uint32_t BitsetCountBits(uint32_t x) + { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0F0F0F0F; + return (uint32_t)((x * 0x01010101) >> 24); + } + #else + inline uint32_t BitsetCountBits(uint64_t x) + { + // GCC 3.x's implementation of UINT64_C is broken and fails to deal with + // the code below correctly. So we make a workaround for it. Earlier and + // later versions of GCC don't have this bug. + #if defined(__GNUC__) && (__GNUC__ == 3) + x = x - ((x >> 1) & 0x5555555555555555ULL); + x = (x & 0x3333333333333333ULL) + ((x >> 2) & 0x3333333333333333ULL); + x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0FULL; + return (uint32_t)((x * 0x0101010101010101ULL) >> 56); + #else + x = x - ((x >> 1) & UINT64_C(0x5555555555555555)); + x = (x & UINT64_C(0x3333333333333333)) + ((x >> 2) & UINT64_C(0x3333333333333333)); + x = (x + (x >> 4)) & UINT64_C(0x0F0F0F0F0F0F0F0F); + return (uint32_t)((x * UINT64_C(0x0101010101010101)) >> 56); + #endif + } + #endif + + // const static char kBitsPerUint16[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; + #define EASTL_BITSET_COUNT_STRING "\0\1\1\2\1\2\2\3\1\2\2\3\2\3\3\4" + + + + /////////////////////////////////////////////////////////////////////////// + // BitsetBase + // + // We tried two forms of array access here: + // for(word_type *pWord(mWord), *pWordEnd(mWord + NW); pWord < pWordEnd; ++pWord) + // *pWord = ... + // and + // for(size_t i = 0; i < NW; i++) + // mWord[i] = ... + // + // For our tests (~NW < 16), the latter (using []) access resulted in faster code. + /////////////////////////////////////////////////////////////////////////// + + template + inline BitsetBase::BitsetBase() + { + reset(); + } + + + template + inline BitsetBase::BitsetBase(uint32_t value) + { + // This implementation assumes that sizeof(value) <= sizeof(BitsetWordType). + EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType)); + + reset(); + mWord[0] = static_cast(value); + } + + + template + inline void BitsetBase::operator&=(const this_type& x) + { + for(size_t i = 0; i < NW; i++) + mWord[i] &= x.mWord[i]; + } + + + template + inline void BitsetBase::operator|=(const this_type& x) + { + for(size_t i = 0; i < NW; i++) + mWord[i] |= x.mWord[i]; + } + + + template + inline void BitsetBase::operator^=(const this_type& x) + { + for(size_t i = 0; i < NW; i++) + mWord[i] ^= x.mWord[i]; + } + + + template + inline void BitsetBase::operator<<=(size_type n) + { + const size_type nWordShift = (size_type)(n >> kBitsPerWordShift); + + if(nWordShift) + { + for(int i = (int)(NW - 1); i >= 0; --i) + mWord[i] = (nWordShift <= (size_type)i) ? mWord[i - nWordShift] : (word_type)0; + } + + if(n &= kBitsPerWordMask) + { + for(size_t i = (NW - 1); i > 0; --i) + mWord[i] = (word_type)((mWord[i] << n) | (mWord[i - 1] >> (kBitsPerWord - n))); + mWord[0] <<= n; + } + + // We let the parent class turn off any upper bits. + } + + + template + inline void BitsetBase::operator>>=(size_type n) + { + const size_type nWordShift = (size_type)(n >> kBitsPerWordShift); + + if(nWordShift) + { + for(size_t i = 0; i < NW; ++i) + mWord[i] = ((nWordShift < (NW - i)) ? mWord[i + nWordShift] : (word_type)0); + } + + if(n &= kBitsPerWordMask) + { + for(size_t i = 0; i < (NW - 1); ++i) + mWord[i] = (word_type)((mWord[i] >> n) | (mWord[i + 1] << (kBitsPerWord - n))); + mWord[NW - 1] >>= n; + } + } + + + template + inline void BitsetBase::flip() + { + for(size_t i = 0; i < NW; i++) + mWord[i] = ~mWord[i]; + // We let the parent class turn off any upper bits. + } + + + template + inline void BitsetBase::set() + { + for(size_t i = 0; i < NW; i++) + mWord[i] = ~static_cast(0); + // We let the parent class turn off any upper bits. + } + + + template + inline void BitsetBase::set(size_type i, bool value) + { + if(value) + mWord[i >> kBitsPerWordShift] |= (static_cast(1) << (i & kBitsPerWordMask)); + else + mWord[i >> kBitsPerWordShift] &= ~(static_cast(1) << (i & kBitsPerWordMask)); + } + + + template + inline void BitsetBase::reset() + { + if(NW > 16) // This is a constant expression and should be optimized away. + { + // This will be fastest if compiler intrinsic function optimizations are enabled. + memset(mWord, 0, sizeof(mWord)); + } + else + { + for(size_t i = 0; i < NW; i++) + mWord[i] = 0; + } + } + + + template + inline bool BitsetBase::operator==(const this_type& x) const + { + for(size_t i = 0; i < NW; i++) + { + if(mWord[i] != x.mWord[i]) + return false; + } + return true; + } + + + template + inline bool BitsetBase::any() const + { + for(size_t i = 0; i < NW; i++) + { + if(mWord[i]) + return true; + } + return false; + } + + + template + inline typename BitsetBase::size_type + BitsetBase::count() const + { + size_type n = 0; + + for(size_t i = 0; i < NW; i++) + { + #if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later + #if(EA_PLATFORM_WORD_SIZE == 4) + n += (size_type)__builtin_popcountl(mWord[i]); + #else + n += (size_type)__builtin_popcountll(mWord[i]); + #endif + #elif defined(__GNUC__) && (__GNUC__ < 3) + n += BitsetCountBits(mWord[i]); // GCC 2.x compiler inexplicably blows up on the code below. + #else + for(word_type w = mWord[i]; w; w >>= 4) + n += EASTL_BITSET_COUNT_STRING[w & 0xF]; + + // Version which seems to run slower in benchmarks: + // n += BitsetCountBits(mWord[i]); + #endif + + } + return n; + } + + + template + inline unsigned long BitsetBase::to_ulong() const + { + #if EASTL_EXCEPTIONS_ENABLED + for(size_t i = 1; i < NW; ++i) + { + if(mWord[i]) + throw overflow_error("BitsetBase::to_ulong"); + } + #endif + return (unsigned long)mWord[0]; // Todo: We need to deal with the case whereby sizeof(word_type) < sizeof(unsigned long) + } + + + template + inline typename BitsetBase::word_type& + BitsetBase::DoGetWord(size_type i) + { + return mWord[i >> kBitsPerWordShift]; + } + + + template + inline typename BitsetBase::word_type + BitsetBase::DoGetWord(size_type i) const + { + return mWord[i >> kBitsPerWordShift]; + } + + + #if(EA_PLATFORM_WORD_SIZE == 4) + inline uint32_t GetFirstBit(uint32_t x) + { + if(x) + { + uint32_t n = 1; + + if((x & 0x0000FFFF) == 0) { n += 16; x >>= 16; } + if((x & 0x000000FF) == 0) { n += 8; x >>= 8; } + if((x & 0x0000000F) == 0) { n += 4; x >>= 4; } + if((x & 0x00000003) == 0) { n += 2; x >>= 2; } + + return (n - ((uint32_t)x & 1)); + } + + return 32; + } + #else + inline uint32_t GetFirstBit(uint64_t x) + { + if(x) + { + uint32_t n = 1; + + if((x & 0xFFFFFFFF) == 0) { n += 32; x >>= 32; } + if((x & 0x0000FFFF) == 0) { n += 16; x >>= 16; } + if((x & 0x000000FF) == 0) { n += 8; x >>= 8; } + if((x & 0x0000000F) == 0) { n += 4; x >>= 4; } + if((x & 0x00000003) == 0) { n += 2; x >>= 2; } + + return (n - ((uint32_t)x & 1)); + } + + return 64; + } + #endif + + + template + inline typename BitsetBase::size_type + BitsetBase::DoFindFirst() const + { + for(size_type word_index = 0; word_index < NW; ++word_index) + { + const size_type fbiw = GetFirstBit(mWord[word_index]); + + if(fbiw != kBitsPerWord) + return (word_index * kBitsPerWord) + fbiw; + } + + return (size_type)NW * kBitsPerWord; + } + + + template + inline typename BitsetBase::size_type + BitsetBase::DoFindNext(size_type last_find) const + { + // Start looking from the next bit. + ++last_find; + + // Set initial state based on last find. + size_type word_index = static_cast(last_find >> kBitsPerWordShift); + size_type bit_index = static_cast(last_find & kBitsPerWordMask); + + // To do: There probably is a more elegant way to write looping below. + if(word_index < NW) + { + // Mask off previous bits of the word so our search becomes a "find first". + word_type this_word = mWord[word_index] & (~static_cast(0) << bit_index); + + for(;;) + { + const size_type fbiw = GetFirstBit(this_word); + + if(fbiw != kBitsPerWord) + return (word_index * kBitsPerWord) + fbiw; + + if(++word_index < NW) + this_word = mWord[word_index]; + else + break; + } + } + + return (size_type)NW * kBitsPerWord; + } + + + #if(EA_PLATFORM_WORD_SIZE == 4) + inline uint32_t GetLastBit(uint32_t x) + { + if(x) + { + uint32_t n = 0; + + if(x & 0xFFFF0000) { n += 16; x >>= 16; } + if(x & 0xFFFFFF00) { n += 8; x >>= 8; } + if(x & 0xFFFFFFF0) { n += 4; x >>= 4; } + if(x & 0xFFFFFFFC) { n += 2; x >>= 2; } + if(x & 0xFFFFFFFE) { n += 1; } + + return n; + } + + return 32; + } + #else + inline uint32_t GetLastBit(uint64_t x) + { + if(x) + { + uint32_t n = 0; + + if(x & UINT64_C(0xFFFFFFFF00000000)) { n += 32; x >>= 32; } + if(x & 0xFFFF0000) { n += 16; x >>= 16; } + if(x & 0xFFFFFF00) { n += 8; x >>= 8; } + if(x & 0xFFFFFFF0) { n += 4; x >>= 4; } + if(x & 0xFFFFFFFC) { n += 2; x >>= 2; } + if(x & 0xFFFFFFFE) { n += 1; } + + return n; + } + + return 64; + } + #endif + + template + inline typename BitsetBase::size_type + BitsetBase::DoFindLast() const + { + for(size_t word_index = (size_type)NW - 1; word_index < NW; --word_index) + { + const size_type lbiw = GetLastBit(mWord[word_index]); + + if(lbiw != kBitsPerWord) + return (word_index * kBitsPerWord) + lbiw; + } + + return (size_type)NW * kBitsPerWord; + } + + + template + inline typename BitsetBase::size_type + BitsetBase::DoFindPrev(size_type last_find) const + { + if(last_find > 0) + { + // Set initial state based on last find. + size_type word_index = static_cast(last_find >> kBitsPerWordShift); + size_type bit_index = static_cast(last_find & kBitsPerWordMask); + + // Mask off subsequent bits of the word so our search becomes a "find last". + word_type mask = (~static_cast(0) >> (kBitsPerWord - 1 - bit_index)) >> 1; // We do two shifts here because many CPUs ignore requests to shift 32 bit integers by 32 bits, which could be the case above. + word_type this_word = mWord[word_index] & mask; + + for(;;) + { + const size_type lbiw = GetLastBit(this_word); + + if(lbiw != kBitsPerWord) + return (word_index * kBitsPerWord) + lbiw; + + if(word_index > 0) + this_word = mWord[--word_index]; + else + break; + } + } + + return (size_type)NW * kBitsPerWord; + } + + + + /////////////////////////////////////////////////////////////////////////// + // BitsetBase<1> + /////////////////////////////////////////////////////////////////////////// + + inline BitsetBase<1>::BitsetBase() + { + mWord[0] = 0; + } + + + inline BitsetBase<1>::BitsetBase(uint32_t value) + { + // This implementation assumes that sizeof(value) <= sizeof(BitsetWordType). + EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType)); + + mWord[0] = static_cast(value); + } + + + inline void BitsetBase<1>::operator&=(const this_type& x) + { + mWord[0] &= x.mWord[0]; + } + + + inline void BitsetBase<1>::operator|=(const this_type& x) + { + mWord[0] |= x.mWord[0]; + } + + + inline void BitsetBase<1>::operator^=(const this_type& x) + { + mWord[0] ^= x.mWord[0]; + } + + + inline void BitsetBase<1>::operator<<=(size_type n) + { + mWord[0] <<= n; + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<1>::operator>>=(size_type n) + { + mWord[0] >>= n; + } + + + inline void BitsetBase<1>::flip() + { + mWord[0] = ~mWord[0]; + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<1>::set() + { + mWord[0] = ~static_cast(0); + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<1>::set(size_type i, bool value) + { + if(value) + mWord[0] |= (static_cast(1) << i); + else + mWord[0] &= ~(static_cast(1) << i); + } + + + inline void BitsetBase<1>::reset() + { + mWord[0] = 0; + } + + + inline bool BitsetBase<1>::operator==(const this_type& x) const + { + return mWord[0] == x.mWord[0]; + } + + + inline bool BitsetBase<1>::any() const + { + return mWord[0] != 0; + } + + + inline BitsetBase<1>::size_type + BitsetBase<1>::count() const + { + #if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later + #if(EA_PLATFORM_WORD_SIZE == 4) + return (size_type)__builtin_popcountl(mWord[0]); + #else + return (size_type)__builtin_popcountll(mWord[0]); + #endif + #elif defined(__GNUC__) && (__GNUC__ < 3) + return BitsetCountBits(mWord[0]); // GCC 2.x compiler inexplicably blows up on the code below. + #else + size_type n = 0; + for(word_type w = mWord[0]; w; w >>= 4) + n += EASTL_BITSET_COUNT_STRING[w & 0xF]; + return n; + #endif + } + + + inline unsigned long BitsetBase<1>::to_ulong() const + { + return static_cast(mWord[0]); + } + + + inline BitsetBase<1>::word_type& + BitsetBase<1>::DoGetWord(size_type) + { + return mWord[0]; + } + + + inline BitsetBase<1>::word_type + BitsetBase<1>::DoGetWord(size_type) const + { + return mWord[0]; + } + + + inline BitsetBase<1>::size_type + BitsetBase<1>::DoFindFirst() const + { + return GetFirstBit(mWord[0]); + } + + + inline BitsetBase<1>::size_type + BitsetBase<1>::DoFindNext(size_type last_find) const + { + if(++last_find < kBitsPerWord) + { + // Mask off previous bits of word so our search becomes a "find first". + const word_type this_word = mWord[0] & ((~static_cast(0)) << last_find); + + return GetFirstBit(this_word); + } + + return kBitsPerWord; + } + + + inline BitsetBase<1>::size_type + BitsetBase<1>::DoFindLast() const + { + return GetLastBit(mWord[0]); + } + + + inline BitsetBase<1>::size_type + BitsetBase<1>::DoFindPrev(size_type last_find) const + { + if(last_find > 0) + { + // Mask off previous bits of word so our search becomes a "find first". + const word_type this_word = mWord[0] & ((~static_cast(0)) >> (kBitsPerWord - last_find)); + + return GetLastBit(this_word); + } + + return kBitsPerWord; + } + + + + + /////////////////////////////////////////////////////////////////////////// + // BitsetBase<2> + /////////////////////////////////////////////////////////////////////////// + + inline BitsetBase<2>::BitsetBase() + { + mWord[0] = 0; + mWord[1] = 0; + } + + + inline BitsetBase<2>::BitsetBase(uint32_t value) + { + // This implementation assumes that sizeof(value) <= sizeof(BitsetWordType). + EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType)); + + mWord[0] = static_cast(value); + mWord[1] = 0; + } + + + inline void BitsetBase<2>::operator&=(const this_type& x) + { + mWord[0] &= x.mWord[0]; + mWord[1] &= x.mWord[1]; + } + + + inline void BitsetBase<2>::operator|=(const this_type& x) + { + mWord[0] |= x.mWord[0]; + mWord[1] |= x.mWord[1]; + } + + + inline void BitsetBase<2>::operator^=(const this_type& x) + { + mWord[0] ^= x.mWord[0]; + mWord[1] ^= x.mWord[1]; + } + + + inline void BitsetBase<2>::operator<<=(size_type n) + { + if(EASTL_UNLIKELY(n >= kBitsPerWord)) // parent expected to handle high bits and n >= 64 + { + mWord[1] = mWord[0]; + mWord[0] = 0; + n -= kBitsPerWord; + } + + mWord[1] = (mWord[1] << n) | (mWord[0] >> (kBitsPerWord - n)); // Intentionally use | instead of +. + mWord[0] <<= n; + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<2>::operator>>=(size_type n) + { + if(EASTL_UNLIKELY(n >= kBitsPerWord)) // parent expected to handle n >= 64 + { + mWord[0] = mWord[1]; + mWord[1] = 0; + n -= kBitsPerWord; + } + + mWord[0] = (mWord[0] >> n) | (mWord[1] << (kBitsPerWord - n)); // Intentionally use | instead of +. + mWord[1] >>= n; + } + + + inline void BitsetBase<2>::flip() + { + mWord[0] = ~mWord[0]; + mWord[1] = ~mWord[1]; + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<2>::set() + { + mWord[0] = ~static_cast(0); + mWord[1] = ~static_cast(0); + // We let the parent class turn off any upper bits. + } + + + inline void BitsetBase<2>::set(size_type i, bool value) + { + if(value) + mWord[i >> kBitsPerWordShift] |= (static_cast(1) << (i & kBitsPerWordMask)); + else + mWord[i >> kBitsPerWordShift] &= ~(static_cast(1) << (i & kBitsPerWordMask)); + } + + + inline void BitsetBase<2>::reset() + { + mWord[0] = 0; + mWord[1] = 0; + } + + + inline bool BitsetBase<2>::operator==(const this_type& x) const + { + return (mWord[0] == x.mWord[0]) && (mWord[1] == x.mWord[1]); + } + + + inline bool BitsetBase<2>::any() const + { + // Or with two branches: { return (mWord[0] != 0) || (mWord[1] != 0); } + return (mWord[0] | mWord[1]) != 0; + } + + + inline BitsetBase<2>::size_type + BitsetBase<2>::count() const + { + #if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later + #if(EA_PLATFORM_WORD_SIZE == 4) + return (size_type)__builtin_popcountl(mWord[0]) + (size_type)__builtin_popcountl(mWord[1]); + #else + return (size_type)__builtin_popcountll(mWord[0]) + (size_type)__builtin_popcountll(mWord[1]); + #endif + + #else + return BitsetCountBits(mWord[0]) + BitsetCountBits(mWord[1]); + #endif + } + + + inline unsigned long BitsetBase<2>::to_ulong() const + { + #if EASTL_EXCEPTIONS_ENABLED + if(mWord[1]) + throw overflow_error("BitsetBase::to_ulong"); + #endif + return (unsigned long)mWord[0]; // Todo: We need to deal with the case whereby sizeof(word_type) < sizeof(unsigned long) + } + + + inline BitsetBase<2>::word_type& + BitsetBase<2>::DoGetWord(size_type i) + { + return mWord[i >> kBitsPerWordShift]; + } + + + inline BitsetBase<2>::word_type + BitsetBase<2>::DoGetWord(size_type i) const + { + return mWord[i >> kBitsPerWordShift]; + } + + + inline BitsetBase<2>::size_type + BitsetBase<2>::DoFindFirst() const + { + size_type fbiw = GetFirstBit(mWord[0]); + + if(fbiw != kBitsPerWord) + return fbiw; + + fbiw = GetFirstBit(mWord[1]); + + if(fbiw != kBitsPerWord) + return kBitsPerWord + fbiw; + + return 2 * kBitsPerWord; + } + + + inline BitsetBase<2>::size_type + BitsetBase<2>::DoFindNext(size_type last_find) const + { + // If the last find was in the first word, we must check it and then possibly the second. + if(++last_find < (size_type)kBitsPerWord) + { + // Mask off previous bits of word so our search becomes a "find first". + word_type this_word = mWord[0] & ((~static_cast(0)) << last_find); + + // Step through words. + size_type fbiw = GetFirstBit(this_word); + + if(fbiw != kBitsPerWord) + return fbiw; + + fbiw = GetFirstBit(mWord[1]); + + if(fbiw != kBitsPerWord) + return kBitsPerWord + fbiw; + } + else if(last_find < (size_type)(2 * kBitsPerWord)) + { + // The last find was in the second word, remove the bit count of the first word from the find. + last_find -= kBitsPerWord; + + // Mask off previous bits of word so our search becomes a "find first". + word_type this_word = mWord[1] & ((~static_cast(0)) << last_find); + + const size_type fbiw = GetFirstBit(this_word); + + if(fbiw != kBitsPerWord) + return kBitsPerWord + fbiw; + } + + return 2 * kBitsPerWord; + } + + + inline BitsetBase<2>::size_type + BitsetBase<2>::DoFindLast() const + { + size_type lbiw = GetLastBit(mWord[1]); + + if(lbiw != kBitsPerWord) + return kBitsPerWord + lbiw; + + lbiw = GetLastBit(mWord[0]); + + if(lbiw != kBitsPerWord) + return lbiw; + + return 2 * kBitsPerWord; + } + + + inline BitsetBase<2>::size_type + BitsetBase<2>::DoFindPrev(size_type last_find) const + { + // If the last find was in the second word, we must check it and then possibly the first. + if(last_find > (size_type)kBitsPerWord) + { + // This has the same effect as last_find %= kBitsPerWord in our case. + last_find -= kBitsPerWord; + + // Mask off previous bits of word so our search becomes a "find first". + word_type this_word = mWord[1] & ((~static_cast(0)) >> (kBitsPerWord - last_find)); + + // Step through words. + size_type lbiw = GetLastBit(this_word); + + if(lbiw != kBitsPerWord) + return kBitsPerWord + lbiw; + + lbiw = GetLastBit(mWord[0]); + + if(lbiw != kBitsPerWord) + return lbiw; + } + else if(last_find != 0) + { + // Mask off previous bits of word so our search becomes a "find first". + word_type this_word = mWord[0] & ((~static_cast(0)) >> (kBitsPerWord - last_find)); + + const size_type lbiw = GetLastBit(this_word); + + if(lbiw != kBitsPerWord) + return lbiw; + } + + return 2 * kBitsPerWord; + } + + + + /////////////////////////////////////////////////////////////////////////// + // bitset::reference + /////////////////////////////////////////////////////////////////////////// + + template + inline bitset::reference::reference(const bitset& x, size_type i) + : mpBitWord(&const_cast(x).DoGetWord(i)), + mnBitIndex(i & kBitsPerWordMask) + { // We have an issue here because the above is casting away the const-ness of the source bitset. + // Empty + } + + + template + inline typename bitset::reference& + bitset::reference::operator=(bool value) + { + if(value) + *mpBitWord |= (static_cast(1) << (mnBitIndex & kBitsPerWordMask)); + else + *mpBitWord &= ~(static_cast(1) << (mnBitIndex & kBitsPerWordMask)); + return *this; + } + + + template + inline typename bitset::reference& + bitset::reference::operator=(const reference& x) + { + if(*x.mpBitWord & (static_cast(1) << (x.mnBitIndex & kBitsPerWordMask))) + *mpBitWord |= (static_cast(1) << (mnBitIndex & kBitsPerWordMask)); + else + *mpBitWord &= ~(static_cast(1) << (mnBitIndex & kBitsPerWordMask)); + return *this; + } + + + template + inline bool bitset::reference::operator~() const + { + return (*mpBitWord & (static_cast(1) << (mnBitIndex & kBitsPerWordMask))) == 0; + } + + + //Defined inline in the class because Metrowerks fails to be able to compile it here. + //template + //inline bitset::reference::operator bool() const + //{ + // return (*mpBitWord & (static_cast(1) << (mnBitIndex & kBitsPerWordMask))) != 0; + //} + + + template + inline typename bitset::reference& + bitset::reference::flip() + { + *mpBitWord ^= static_cast(1) << (mnBitIndex & kBitsPerWordMask); + return *this; + } + + + + + /////////////////////////////////////////////////////////////////////////// + // bitset + /////////////////////////////////////////////////////////////////////////// + + template + inline bitset::bitset() + : base_type() + { + // Empty. The base class will set all bits to zero. + } + + + template + inline bitset::bitset(uint32_t value) + : base_type(value) + { + if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32. + mWord[kNW - 1] &= ~(~static_cast(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. + } + + + template + inline typename bitset::this_type& + bitset::operator&=(const this_type& x) + { + base_type::operator&=(x); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::operator|=(const this_type& x) + { + base_type::operator|=(x); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::operator^=(const this_type& x) + { + base_type::operator^=(x); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::operator<<=(size_type n) + { + if(EASTL_LIKELY((intptr_t)n < (intptr_t)N)) + { + base_type::operator<<=(n); + if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32. + mWord[kNW - 1] &= ~(~static_cast(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly. + } + else + base_type::reset(); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::operator>>=(size_type n) + { + if(EASTL_LIKELY(n < N)) + base_type::operator>>=(n); + else + base_type::reset(); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::set() + { + base_type::set(); // This sets all bits. + if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32. + mWord[kNW - 1] &= ~(~static_cast(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly. + return *this; + } + + + template + inline typename bitset::this_type& + bitset::set(size_type i, bool value) + { + if(i < N) + base_type::set(i, value); + + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::set -- out of range"); + #endif + + #if EASTL_EXCEPTIONS_ENABLED + else + throw out_of_range("bitset::set"); + #endif + return *this; + } + + + template + inline typename bitset::this_type& + bitset::reset() + { + base_type::reset(); + return *this; + } + + + template + inline typename bitset::this_type& + bitset::reset(size_type i) + { + if(EASTL_LIKELY(i < N)) + DoGetWord(i) &= ~(static_cast(1) << (i & kBitsPerWordMask)); + + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::reset -- out of range"); + #endif + + #if EASTL_EXCEPTIONS_ENABLED + else + throw out_of_range("bitset::reset"); + #endif + return *this; + } + + + template + inline typename bitset::this_type& + bitset::flip() + { + base_type::flip(); + if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32. + mWord[kNW - 1] &= ~(~static_cast(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly. + return *this; + } + + + template + inline typename bitset::this_type& + bitset::flip(size_type i) + { + if(EASTL_LIKELY(i < N)) + DoGetWord(i) ^= (static_cast(1) << (i & kBitsPerWordMask)); + + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::flip -- out of range"); + #endif + + #if EASTL_EXCEPTIONS_ENABLED + else + throw out_of_range("bitset::flip"); + #endif + return *this; + } + + + template + inline typename bitset::this_type + bitset::operator~() const + { + return this_type(*this).flip(); + } + + + template + inline typename bitset::reference + bitset::operator[](size_type i) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::operator[] -- out of range"); + #endif + + return reference(*this, i); + } + + + template + inline bool bitset::operator[](size_type i) const + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::operator[] -- out of range"); + #endif + + return (DoGetWord(i) & (static_cast(1) << (i & kBitsPerWordMask))) != 0; + } + + + template + inline const typename bitset::word_type* bitset::data() const + { + return base_type::mWord; + } + + + template + inline typename bitset::word_type* bitset::data() + { + return base_type::mWord; + } + + + template + inline unsigned long bitset::to_ulong() const + { + return base_type::to_ulong(); + } + + + template + inline typename bitset::size_type + bitset::count() const + { + return base_type::count(); + } + + + template + inline typename bitset::size_type + bitset::size() const + { + return (size_type)N; + } + + + template + inline bool bitset::operator==(const this_type& x) const + { + return base_type::operator==(x); + } + + + template + inline bool bitset::operator!=(const this_type& x) const + { + return !base_type::operator==(x); + } + + + template + inline bool bitset::test(size_type i) const + { + if(EASTL_LIKELY(i < N)) + return (DoGetWord(i) & (static_cast(1) << (i & kBitsPerWordMask))) != 0; + + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(!(i < N))) + EASTL_FAIL_MSG("bitset::test -- out of range"); + #endif + + #if EASTL_EXCEPTIONS_ENABLED + else + throw out_of_range("bitset::test"); + #endif + return false; + } + + + template + inline bool bitset::any() const + { + return base_type::any(); + } + + + template + inline bool bitset::none() const + { + return !base_type::any(); + } + + + template + inline typename bitset::this_type + bitset::operator<<(size_type n) const + { + return this_type(*this).operator<<=(n); + } + + + template + inline typename bitset::this_type + bitset::operator>>(size_type n) const + { + return this_type(*this).operator>>=(n); + } + + + template + inline typename bitset::size_type + bitset::find_first() const + { + const size_type i = base_type::DoFindFirst(); + + if(i < (kNW * kBitsPerWord)) // This multiplication is a compile-time constant. + return i; + + return kSize; + } + + + template + inline typename bitset::size_type + bitset::find_next(size_type last_find) const + { + const size_type i = base_type::DoFindNext(last_find); + + if(i < (kNW * kBitsPerWord))// This multiplication is a compile-time constant. + return i; + + return kSize; + } + + + template + inline typename bitset::size_type + bitset::find_last() const + { + const size_type i = base_type::DoFindLast(); + + if(i < (kNW * kBitsPerWord)) // This multiplication is a compile-time constant. + return i; + + return kSize; + } + + + template + inline typename bitset::size_type + bitset::find_prev(size_type last_find) const + { + const size_type i = base_type::DoFindPrev(last_find); + + if(i < (kNW * kBitsPerWord))// This multiplication is a compile-time constant. + return i; + + return kSize; + } + + + + /////////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////////// + + template + inline bitset operator&(const bitset& a, const bitset& b) + { + // We get betting inlining when we don't declare temporary variables. + return bitset(a).operator&=(b); + } + + + template + inline bitset operator|(const bitset& a, const bitset& b) + { + return bitset(a).operator|=(b); + } + + + template + inline bitset operator^(const bitset& a, const bitset& b) + { + return bitset(a).operator^=(b); + } + + +} // namespace eastl + + +#if defined(_MSC_VER) + #pragma warning(pop) +#elif defined(__SNC__) + #pragma control %pop diag +#endif + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/bonus/sort_extra.h b/lib/eastl/include/EASTL/bonus/sort_extra.h new file mode 100644 index 0000000..02f7c6a --- /dev/null +++ b/lib/eastl/include/EASTL/bonus/sort_extra.h @@ -0,0 +1,482 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/sort_extra.h +// Written by Paul Pedriana - 2005 +////////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////////// +// This file implements additional sort algorithms beyond the basic set. +// Included here are: +// radix_sort +// comb_sort +// bubble_sort +// selection_sort +// shaker_sort +// bucket_sort +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_SORT_EXTRA_H +#define EASTL_SORT_EXTRA_H + +#include +#include +#include +#include +#include +#include + +namespace eastl +{ + + /// extract_radix_key + /// + /// Default radix sort integer value reader. It expects the sorted elements + /// to have an integer member of type radix_type and of name "mKey". + /// + template + struct extract_radix_key + { + typedef typename Node::radix_type radix_type; + + const radix_type operator()(const Node& x) const + { return x.mKey; } + }; + + + /// radix_sort + /// + /// Implements a classic LSD (least significant digit) radix sort. + /// See http://en.wikipedia.org/wiki/Radix_sort. + /// To consider: A static linked-list implementation may be faster than the version here. + /// + /// Example usage: + /// struct Element { + /// typedef uint16_t radix_type; + /// uint16_t mKey; + /// uint16_t mData; + /// }; + /// + /// Element elementArray[100]; + /// Element buffer[100]; + /// + /// radix_sort >(elementArray, elementArray + 100, buffer); + /// + template + void radix_sort_impl(RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator buffer, ExtractKey extractKey, uint8_t) + { + uint32_t EA_PREFIX_ALIGN(16) bucketSize[256] EA_POSTFIX_ALIGN(16); + uint32_t EA_PREFIX_ALIGN(16) bucketPosition[256] EA_POSTFIX_ALIGN(16); + RandomAccessIterator temp; + uint32_t i; + + memset(bucketSize, 0, sizeof(bucketSize)); + + for(temp = first; temp != last; ++temp) + ++bucketSize[extractKey(*temp)]; + + for(bucketPosition[0] = 0, i = 0; i < 255; i++) + bucketPosition[i + 1] = bucketPosition[i] + bucketSize[i]; + + for(temp = first; temp != last; ++temp) + { + const size_t radixByte = extractKey(*temp); + buffer[bucketPosition[radixByte]++] = *temp; + } + } + + + template + void radix_sort_impl(RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator buffer, ExtractKey extractKey, uint16_t) + { + uint32_t EA_PREFIX_ALIGN(16) bucketSize[256] EA_POSTFIX_ALIGN(16); + uint32_t EA_PREFIX_ALIGN(16) bucketPosition[256] EA_POSTFIX_ALIGN(16); + RandomAccessIterator temp; + uint32_t i; + + // Process byte 0 (least significant byte). + memset(bucketSize, 0, sizeof(bucketSize)); + + for(temp = first; temp != last; ++temp) + ++bucketSize[extractKey(*temp) & 0xff]; + + for(bucketPosition[0] = 0, i = 0; i < 255; i++) + bucketPosition[i + 1] = bucketPosition[i] + bucketSize[i]; + + for(temp = first; temp != last; ++temp) + { + const size_t radixByte = extractKey(*temp) & 0xff; + buffer[bucketPosition[radixByte]++] = *temp; + } + + + // Process byte 1 (second least significant byte). + memset(bucketSize, 0, sizeof(bucketSize)); + + for(temp = buffer, last = buffer + (last - first); temp != last; ++temp) + ++bucketSize[extractKey(*temp) >> 8]; + + for(bucketPosition[0] = 0, i = 0; i < 255; i++) + bucketPosition[i + 1] = bucketPosition[i] + bucketSize[i]; + + for(temp = buffer; temp != last; ++temp) + { + const size_t radixByte = extractKey(*temp) >> 8; + first[bucketPosition[radixByte]++] = *temp; + } + } + + + template + void radix_sort_impl(RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator buffer, ExtractKey extractKey, IntegerType) + { + uint32_t EA_PREFIX_ALIGN(16) bucketSize[256] EA_POSTFIX_ALIGN(16); + uint32_t EA_PREFIX_ALIGN(16) bucketPosition[256] EA_POSTFIX_ALIGN(16); + RandomAccessIterator temp; + uint32_t i; + + for(uint32_t j = 0; j < (8 * sizeof(IntegerType)); j += 8) + { + memset(bucketSize, 0, sizeof(bucketSize)); + + for(temp = first; temp != last; ++temp) + ++bucketSize[(extractKey(*temp) >> j) & 0xff]; + + bucketPosition[0] = 0; + for(i = 0; i < 255; i++) + bucketPosition[i + 1] = bucketPosition[i] + bucketSize[i]; + + for(temp = first; temp != last; ++temp) + { + const size_t radixByte = ((extractKey(*temp) >> j) & 0xff); + buffer[bucketPosition[radixByte]++] = *temp; + } + + last = buffer + (last - first); + temp = first; + first = buffer; + buffer = temp; + } + } + + + template + void radix_sort(RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator buffer) + { + radix_sort_impl(first, last, buffer, ExtractKey(), typename ExtractKey::radix_type()); + } + + + + /// comb_sort + /// + /// Implements the CombSort algorithm; in particular, implements the CombSort11 variation + /// of the CombSort algorithm, based on the reference to '11' in the implementation. + /// + /// To consider: Use a comb sort table instead of the '((nSpace * 10) + 3) / 13' expression. + /// Ideal tables can be found on the Internet by looking up "comb sort table". + /// + template + void comb_sort(ForwardIterator first, ForwardIterator last, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + + ForwardIterator iCurrent, iNext; + difference_type length = eastl::distance(first, last); + difference_type nSpace = length; + + for(bool bSwapped = false; (nSpace > 1) || bSwapped; ) + { + nSpace = ((nSpace * 10) + 3) / 13; // Integer division is less than ideal. + + if((nSpace == 9) || (nSpace == 10)) + nSpace = 11; + + iCurrent = iNext = first; + eastl::advance(iNext, nSpace); + + for(bSwapped = false; iNext != last; iCurrent++, iNext++) + { + if(compare(*iNext, *iCurrent)) + { + EASTL_VALIDATE_COMPARE(!compare(*iCurrent, *iNext)); // Validate that the compare function is sane. + eastl::iter_swap(iCurrent, iNext); + bSwapped = true; + } + } + } + } // comb_sort + + template + inline void comb_sort(ForwardIterator first, ForwardIterator last) + { + typedef eastl::less::value_type> Less; + + eastl::comb_sort(first, last, Less()); + } + + + + + /// bubble_sort + /// + /// Implements the BubbleSort algorithm. This algorithm is only useful for + /// small range sizes, such as 10 or less items. You may be better off using + /// insertion_sort for cases where bubble_sort works. + /// + template + void bubble_sort_impl(ForwardIterator first, ForwardIterator last, StrictWeakOrdering compare, EASTL_ITC_NS::forward_iterator_tag) + { + ForwardIterator iCurrent, iNext; + + while(first != last) + { + iNext = iCurrent = first; + + for(++iNext; iNext != last; iCurrent = iNext, ++iNext) + { + if(compare(*iNext, *iCurrent)) + { + EASTL_VALIDATE_COMPARE(!compare(*iCurrent, *iNext)); // Validate that the compare function is sane. + eastl::iter_swap(iCurrent, iNext); + } + } + last = iCurrent; + } + } + + template + void bubble_sort_impl(BidirectionalIterator first, BidirectionalIterator last, StrictWeakOrdering compare, EASTL_ITC_NS::bidirectional_iterator_tag) + { + if(first != last) + { + BidirectionalIterator iCurrent, iNext, iLastModified; + + last--; + + while(first != last) + { + iLastModified = iNext = iCurrent = first; + + for(++iNext; iCurrent != last; iCurrent = iNext, ++iNext) + { + if(compare(*iNext, *iCurrent)) + { + EASTL_VALIDATE_COMPARE(!compare(*iCurrent, *iNext)); // Validate that the compare function is sane. + iLastModified = iCurrent; + eastl::iter_swap(iCurrent, iNext); + } + } + + last = iLastModified; + } + } + } + + template + inline void bubble_sort(ForwardIterator first, ForwardIterator last, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::iterator_category IC; + + eastl::bubble_sort_impl(first, last, compare, IC()); + } + + template + inline void bubble_sort(ForwardIterator first, ForwardIterator last) + { + typedef eastl::less::value_type> Less; + typedef typename eastl::iterator_traits::iterator_category IC; + + eastl::bubble_sort_impl(first, last, Less(), IC()); + } + + + + /// selection_sort + /// + /// Implements the SelectionSort algorithm. + /// + template + void selection_sort(ForwardIterator first, ForwardIterator last, StrictWeakOrdering compare) + { + if(first != last) + { + ForwardIterator iCurrent, iMin; + + for(; first != last; ++first) + { + iCurrent = first; + iMin = iCurrent; + + for(++iCurrent; iCurrent != last; ++iCurrent) + { + if(compare(*iCurrent, *iMin)) + { + EASTL_VALIDATE_COMPARE(!compare(*iMin, *iCurrent)); // Validate that the compare function is sane. + iMin = iCurrent; + } + } + + if(first != iMin) + eastl::iter_swap(first, iMin); + } + } + } // selection_sort + + template + inline void selection_sort(ForwardIterator first, ForwardIterator last) + { + typedef eastl::less::value_type> Less; + + eastl::selection_sort(first, last, Less()); + } + + + + /// shaker_sort + /// + /// Implements the ShakerSort algorithm, which is a sorting algorithm which + /// improves on bubble_sort by sweeping both from left to right and right + /// to left, resulting in less iteration. + /// + template + void shaker_sort(BidirectionalIterator first, BidirectionalIterator last, StrictWeakOrdering compare) + { + if(first != last) + { + BidirectionalIterator iCurrent, iNext, iLastModified; + + --last; + + while(first != last) + { + iLastModified = first; + + for(iCurrent = first; iCurrent != last; iCurrent = iNext) + { + iNext = iCurrent; + ++iNext; + + if(compare(*iNext, *iCurrent)) + { + EASTL_VALIDATE_COMPARE(!compare(*iCurrent, *iNext)); // Validate that the compare function is sane. + iLastModified = iCurrent; + eastl::iter_swap(iCurrent, iNext); + } + } + + last = iLastModified; + + if(first != last) + { + for(iCurrent = last; iCurrent != first; iCurrent = iNext) + { + iNext = iCurrent; + --iNext; + + if(compare(*iCurrent, *iNext)) + { + EASTL_VALIDATE_COMPARE(!compare(*iNext, *iCurrent)); // Validate that the compare function is sane. + iLastModified = iCurrent; + eastl::iter_swap(iNext, iCurrent); + } + } + first = iLastModified; + } + } + } + } // shaker_sort + + template + inline void shaker_sort(BidirectionalIterator first, BidirectionalIterator last) + { + typedef eastl::less::value_type> Less; + + eastl::shaker_sort(first, last, Less()); + } + + + + /// bucket_sort + /// + /// Implements the BucketSort algorithm. + /// + /// Example usage: + /// int* pArray = new int[1000]; + /// for(int i = 0; i < 1000; i++) + /// pArray[i] = rand() % 32; // Note: The C rand function is a poor random number generator. + /// vector intVector[32]; + /// bucket_sort(pArray, pArray + 1000; intVector); + /// delete[] pArray; + /// + template + struct hash_use_self + { + T operator()(const T& x) const + { return x; } + }; + + template + void bucket_sort(ForwardIterator first, ForwardIterator last, ContainerArray& bucketArray, HashFunction hash /*= hash_use_self*/) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + + for(ForwardIterator iInput = first; iInput != last; ++iInput) + bucketArray[hash(*iInput)].push_back(*iInput); + + for(typename ContainerArray::const_iterator iBucket = bucketArray.begin(); iBucket != bucketArray.end(); ++iBucket) + first = eastl::copy((*iBucket).begin(), (*iBucket).end(), first); + } + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/core_allocator_adapter.h b/lib/eastl/include/EASTL/core_allocator_adapter.h new file mode 100644 index 0000000..c099dc7 --- /dev/null +++ b/lib/eastl/include/EASTL/core_allocator_adapter.h @@ -0,0 +1,296 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// core_allocator_adapter.h +// +// Copyright (c) 2007, Electronic Arts. All rights reserved. +// Maintained by Paul Pedriana +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Implements an EASTL allocator that uses an ICoreAllocator. +// However, this header file is not dependent on ICoreAllocator or its package. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_CORE_ALLOCATOR_ADAPTER_H +#define EASTL_CORE_ALLOCATOR_ADAPTER_H + + +#include + + +namespace EA +{ + namespace Allocator + { + /// CoreAllocatorAdapter + /// + /// Implements the EASTL allocator interface. + /// Allocates memory from an instance of ICoreAllocator. + /// + /// Example usage: + /// eastl::list > widgetList("UI/WidgetList", pSomeCoreAllocator); + /// widgetList.push_back(Widget()); + /// + /// Example usage: + /// // Note that the CoreAllocator is declared before and thus destroyed after the widget list. + /// typedef CoreAllocatorAdapter EASTLCoreAllocator; + /// typedef eastl::list WidgetList; + /// CoreAllocatorFixed widgetCoreAllocator(pFixedAllocatorForWidgetListValueType); + /// WidgetList widgetList(EASTLCoreAllocator("UI/WidgetList", &widgetCoreAllocator)); + /// + template + class CoreAllocatorAdapter + { + public: + typedef CoreAllocatorAdapter this_type; + + public: + CoreAllocatorAdapter(const char* pName = EASTL_NAME_VAL(EASTL_ALLOCATOR_DEFAULT_NAME)); + CoreAllocatorAdapter(const char* pName, AllocatorType* pAllocator); + CoreAllocatorAdapter(const char* pName, AllocatorType* pAllocator, int flags); + CoreAllocatorAdapter(const CoreAllocatorAdapter& x); + CoreAllocatorAdapter(const CoreAllocatorAdapter& x, const char* pName); + + CoreAllocatorAdapter& operator=(const CoreAllocatorAdapter& x); + + void* allocate(size_t n, int flags = 0); + void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0); + void deallocate(void* p, size_t n); + + AllocatorType* get_allocator() const; + void set_allocator(AllocatorType* pAllocator); + + int get_flags() const; + void set_flags(int flags); + + const char* get_name() const; + void set_name(const char* pName); + + public: // Public because otherwise VC++ generates (possibly invalid) warnings about inline friend template specializations. + AllocatorType* mpCoreAllocator; + int mnFlags; // Allocation flags. See ICoreAllocator/AllocFlags. + + #if EASTL_NAME_ENABLED + const char* mpName; // Debug name, used to track memory. + #endif + }; + + template + bool operator==(const CoreAllocatorAdapter& a, const CoreAllocatorAdapter& b); + + template + bool operator!=(const CoreAllocatorAdapter& a, const CoreAllocatorAdapter& b); + + + + /// EASTLICoreAllocator + /// + /// Provides a standardized typedef for ICoreAllocator; + /// + /// Example usage: + /// eastl::list widgetList("UI/WidgetList", pSomeCoreAllocator); + /// widgetList.push_back(Widget()); + /// + class ICoreAllocator; + typedef CoreAllocatorAdapter EASTLICoreAllocator; + + + } // namespace Allocator + +} // namespace EA + + + + + +/////////////////////////////////////////////////////////////////////////////// +// Inlines +/////////////////////////////////////////////////////////////////////////////// + +namespace EA +{ + namespace Allocator + { + + template + inline CoreAllocatorAdapter::CoreAllocatorAdapter(const char* EASTL_NAME(pName)) + : mpCoreAllocator(AllocatorType::GetDefaultAllocator()), mnFlags(0) + { + #if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; + #endif + } + + template + inline CoreAllocatorAdapter::CoreAllocatorAdapter(const char* EASTL_NAME(pName), AllocatorType* pCoreAllocator) + : mpCoreAllocator(pCoreAllocator), mnFlags(0) + { + #if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; + #endif + } + + template + inline CoreAllocatorAdapter::CoreAllocatorAdapter(const char* EASTL_NAME(pName), AllocatorType* pCoreAllocator, int flags) + : mpCoreAllocator(pCoreAllocator), mnFlags(flags) + { + #if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; + #endif + } + + template + inline CoreAllocatorAdapter::CoreAllocatorAdapter(const CoreAllocatorAdapter& x) + : mpCoreAllocator(x.mpCoreAllocator), mnFlags(x.mnFlags) + { + #if EASTL_NAME_ENABLED + mpName = x.mpName; + #endif + } + + template + inline CoreAllocatorAdapter::CoreAllocatorAdapter(const CoreAllocatorAdapter& x, const char* EASTL_NAME(pName)) + : mpCoreAllocator(x.mpCoreAllocator), mnFlags(x.mnFlags) + { + #if EASTL_NAME_ENABLED + mpName = pName ? pName : EASTL_ALLOCATOR_DEFAULT_NAME; + #endif + } + + template + inline CoreAllocatorAdapter& CoreAllocatorAdapter::operator=(const CoreAllocatorAdapter& x) + { + // In order to be consistent with EASTL's allocator implementation, + // we don't copy the name from the source object. + mpCoreAllocator = x.mpCoreAllocator; + mnFlags = x.mnFlags; + return *this; + } + + template + inline void* CoreAllocatorAdapter::allocate(size_t n, int /*flags*/) + { + // It turns out that EASTL itself doesn't use the flags parameter, + // whereas the user here might well want to specify a flags + // parameter. So we use ours instead of the one passed in. + return mpCoreAllocator->Alloc(n, EASTL_NAME_VAL(mpName), (unsigned)mnFlags); + } + + template + inline void* CoreAllocatorAdapter::allocate(size_t n, size_t alignment, size_t offset, int /*flags*/) + { + // It turns out that EASTL itself doesn't use the flags parameter, + // whereas the user here might well want to specify a flags + // parameter. So we use ours instead of the one passed in. + return mpCoreAllocator->Alloc(n, EASTL_NAME_VAL(mpName), (unsigned)mnFlags, (unsigned)alignment, (unsigned)offset); + } + + template + inline void CoreAllocatorAdapter::deallocate(void* p, size_t n) + { + return mpCoreAllocator->Free(p, n); + } + + template + inline AllocatorType* CoreAllocatorAdapter::get_allocator() const + { + return mpCoreAllocator; + } + + template + inline void CoreAllocatorAdapter::set_allocator(AllocatorType* pAllocator) + { + mpCoreAllocator = pAllocator; + } + + template + inline int CoreAllocatorAdapter::get_flags() const + { + return mnFlags; + } + + template + inline void CoreAllocatorAdapter::set_flags(int flags) + { + mnFlags = flags; + } + + template + inline const char* CoreAllocatorAdapter::get_name() const + { + #if EASTL_NAME_ENABLED + return mpName; + #else + return EASTL_ALLOCATOR_DEFAULT_NAME; + #endif + } + + template + inline void CoreAllocatorAdapter::set_name(const char* pName) + { + #if EASTL_NAME_ENABLED + mpName = pName; + #else + (void)pName; + #endif + } + + + + template + inline bool operator==(const CoreAllocatorAdapter& a, const CoreAllocatorAdapter& b) + { + return (a.mpCoreAllocator == b.mpCoreAllocator) && + (a.mnFlags == b.mnFlags); + } + + template + inline bool operator!=(const CoreAllocatorAdapter& a, const CoreAllocatorAdapter& b) + { + return (a.mpCoreAllocator != b.mpCoreAllocator) || + (a.mnFlags != b.mnFlags); + } + + + } // namespace Allocator + +} // namespace EA + + +#endif // Header include guard + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_allocator.h b/lib/eastl/include/EASTL/fixed_allocator.h new file mode 100644 index 0000000..00fda72 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_allocator.h @@ -0,0 +1,467 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_allocator.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements the following +// fixed_allocator +// fixed_allocator_with_overflow +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_ALLOCATOR_H +#define EASTL_FIXED_ALLOCATOR_H + + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) + #include + #pragma warning(pop) +#else + #include +#endif + + +namespace eastl +{ + + /////////////////////////////////////////////////////////////////////////// + // fixed_allocator + /////////////////////////////////////////////////////////////////////////// + + /// fixed_allocator + /// + /// Implements an allocator which allocates a single fixed size where + /// the size, alignment, and memory used for the pool is defined at + /// runtime by the user. This is different from fixed containers + /// such as fixed_list whereby the size and alignment are determined + /// at compile time and the memory is directly built into the container's + /// member data. + /// + /// If the pool's memory is exhausted or was never initialized, the + /// allocate function returns NULL. Consider the fixed_allocator_with_overflow + /// class as an alternative in order to deal with this situation. + /// + /// This class requires the user to call container.get_allocator().init() + /// after constructing the container. There currently isn't a way to + /// construct the container with the initialization parameters, though + /// with some effort such a thing could probably be made possible. + /// It's not as simple as it might first seem, due to the non-copyable + /// nature of fixed allocators. A side effect of this limitation is that + /// you cannot copy-construct a container using fixed_allocators. + /// + /// Another side-effect is that you cannot swap two containers using + /// a fixed_allocator, as a swap requires temporary memory allocated by + /// an equivalent allocator, and such a thing cannot be done implicitly. + /// A workaround for the swap limitation is that you can implement your + /// own swap whereby you provide an explicitly created temporary object. + /// + /// Note: Be careful to set the allocator's node size to the size of the + /// container node and not the size of the contained object. Note that the + /// example code below uses IntListNode. + /// + /// Example usage: + /// typedef eastl::list IntList; + /// typedef IntList::node_type IntListNode; + /// + /// IntListNode buffer[200]; + /// IntList intList; + /// intList.get_allocator().init(buffer, sizeof(buffer), sizeof(IntListNode), __alignof(IntListNode)); + /// + class EASTL_API fixed_allocator : public fixed_pool_base + { + public: + /// fixed_allocator + /// + /// Default constructor. The user usually will need to call init() after + /// constructing via this constructor. + /// + fixed_allocator(const char* /*pName*/ = EASTL_FIXED_POOL_DEFAULT_NAME) + : fixed_pool_base(NULL) + { + } + + + /// fixed_allocator + /// + /// Copy constructor. The user usually will need to call init() after + /// constructing via this constructor. By their nature, fixed-allocators + /// cannot be copied in any useful way, as by their nature the user + /// must manually initialize them. + /// + fixed_allocator(const fixed_allocator&) + : fixed_pool_base(NULL) + { + } + + + /// operator= + /// + /// By their nature, fixed-allocators cannot be copied in any + /// useful way, as by their nature the user must manually + /// initialize them. + /// + fixed_allocator& operator=(const fixed_allocator&) + { + return *this; + } + + + // init + // + // No init here, as the base class version is sufficient. + // + //void init(void* pMemory, size_t memorySize, size_t nodeSize, + // size_t alignment, size_t alignmentOffset = 0); + + + /// allocate + /// + /// Allocates a new object of the size specified upon class initialization. + /// Returns NULL if there is no more memory. + /// + void* allocate(size_t /*n*/, int /*flags*/ = 0) + { + // To consider: Verify that 'n' is what the user initialized us with. + + Link* pLink = mpHead; + + if(pLink) // If we have space... + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(++mnCurrentSize > mnPeakSize) + mnPeakSize = mnCurrentSize; + #endif + + mpHead = pLink->mpNext; + return pLink; + } + else + { + // If there's no free node in the free list, just + // allocate another from the reserved memory area + + if(mpNext != mpCapacity) + { + pLink = mpNext; + + mpNext = reinterpret_cast(reinterpret_cast(mpNext) + mnNodeSize); + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(++mnCurrentSize > mnPeakSize) + mnPeakSize = mnCurrentSize; + #endif + + return pLink; + } + + // EASTL_ASSERT(false); To consider: enable this assert. However, we intentionally disable it because this isn't necessarily an assertable error. + return NULL; + } + } + + + /// allocate + /// + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int flags = 0) + { + return allocate(n, flags); + } + + + /// deallocate + /// + /// Frees the given object which was allocated by allocate(). + /// If the given node was not allocated by allocate() then the behaviour + /// is undefined. + /// + void deallocate(void* p, size_t) + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + --mnCurrentSize; + #endif + + ((Link*)p)->mpNext = mpHead; + mpHead = ((Link*)p); + } + + + using fixed_pool_base::can_allocate; + + + const char* get_name() const + { + return EASTL_FIXED_POOL_DEFAULT_NAME; + } + + + void set_name(const char*) + { + // Nothing to do. We don't allocate memory. + } + + }; // fixed_allocator + + bool operator==(const fixed_allocator& a, const fixed_allocator& b); + bool operator!=(const fixed_allocator& a, const fixed_allocator& b); + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_allocator_with_overflow + /////////////////////////////////////////////////////////////////////////// + + /// fixed_allocator_with_overflow + /// + /// Implements an allocator which allocates a single fixed size where + /// the size, alignment, and memory used for the pool is defined at + /// runtime by the user. This is different from fixed containers + /// such as fixed_list whereby the size and alignment are determined + /// at compile time and the memory is directly built into the container's + /// member data. + /// + /// Note: Be careful to set the allocator's node size to the size of the + /// container node and not the size of the contained object. Note that the + /// example code below uses IntListNode. + /// + /// This class requires the user to call container.get_allocator().init() + /// after constructing the container. There currently isn't a way to + /// construct the container with the initialization parameters, though + /// with some effort such a thing could probably be made possible. + /// It's not as simple as it might first seem, due to the non-copyable + /// nature of fixed allocators. A side effect of this limitation is that + /// you cannot copy-construct a container using fixed_allocators. + /// + /// Another side-effect is that you cannot swap two containers using + /// a fixed_allocator, as a swap requires temporary memory allocated by + /// an equivalent allocator, and such a thing cannot be done implicitly. + /// A workaround for the swap limitation is that you can implement your + /// own swap whereby you provide an explicitly created temporary object. + /// + /// Example usage: + /// typedef eastl::list IntList; + /// typedef IntList::node_type IntListNode; + /// + /// IntListNode buffer[200]; + /// IntList intList; + /// intList.get_allocator().init(buffer, sizeof(buffer), sizeof(IntListNode), __alignof(IntListNode)); + /// + class EASTL_API fixed_allocator_with_overflow : public fixed_pool_base + { + public: + /// fixed_allocator_with_overflow + /// + /// Default constructor. The user usually will need to call init() after + /// constructing via this constructor. + /// + fixed_allocator_with_overflow(const char* pName = EASTL_FIXED_POOL_DEFAULT_NAME) + : fixed_pool_base(NULL), + mOverflowAllocator(pName) + { + } + + + /// fixed_allocator_with_overflow + /// + /// Copy constructor. The user usually will need to call init() after + /// constructing via this constructor. By their nature, fixed-allocators + /// cannot be copied in any useful way, as by their nature the user + /// must manually initialize them. + /// + fixed_allocator_with_overflow(const fixed_allocator_with_overflow&) + : fixed_pool_base(NULL) + { + } + + + /// operator= + /// + /// By their nature, fixed-allocators cannot be copied in any + /// useful way, as by their nature the user must manually + /// initialize them. + /// + fixed_allocator_with_overflow& operator=(const fixed_allocator_with_overflow& x) + { + #if EASTL_ALLOCATOR_COPY_ENABLED + mOverflowAllocator = x.mOverflowAllocator; + #else + (void)x; + #endif + + return *this; + } + + + /// init + /// + void init(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t alignmentOffset = 0) + { + fixed_pool_base::init(pMemory, memorySize, nodeSize, alignment, alignmentOffset); + + mpPoolBegin = pMemory; + mpPoolEnd = (void*)((uintptr_t)pMemory + memorySize); + mnNodeSize = (eastl_size_t)nodeSize; + } + + + /// allocate + /// + /// Allocates a new object of the size specified upon class initialization. + /// Returns NULL if there is no more memory. + /// + void* allocate(size_t /*n*/, int /*flags*/ = 0) + { + // To consider: Verify that 'n' is what the user initialized us with. + + void* p; + + if(mpHead) // If we have space... + { + p = mpHead; + mpHead = mpHead->mpNext; + } + else + p = mOverflowAllocator.allocate(mnNodeSize); + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(p && (++mnCurrentSize > mnPeakSize)) + mnPeakSize = mnCurrentSize; + #endif + + return p; + } + + + /// allocate + /// + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int flags = 0) + { + return allocate(n, flags); + } + + + /// deallocate + /// + /// Frees the given object which was allocated by allocate(). + /// If the given node was not allocated by allocate() then the behaviour + /// is undefined. + /// + void deallocate(void* p, size_t) + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + --mnCurrentSize; + #endif + + if((p >= mpPoolBegin) && (p < mpPoolEnd)) + { + ((Link*)p)->mpNext = mpHead; + mpHead = ((Link*)p); + } + else + mOverflowAllocator.deallocate(p, (size_t)mnNodeSize); + } + + + using fixed_pool_base::can_allocate; + + + const char* get_name() const + { + return mOverflowAllocator.get_name(); + } + + + void set_name(const char* pName) + { + mOverflowAllocator.set_name(pName); + } + + protected: + EASTLAllocatorType mOverflowAllocator; // To consider: Allow the user to define the type of this, presumably via a template parameter. + void* mpPoolBegin; // To consider: We have these member variables and ideally we shouldn't need them. The problem is that + void* mpPoolEnd; // the information about the pool buffer and object size is stored in the owning container + eastl_size_t mnNodeSize; // and we can't have access to it without increasing the amount of code we need and by templating + // more code. It may turn out that simply storing data here is smaller in the end. + }; // fixed_allocator_with_overflow // Granted, this class is usually used for debugging purposes, but perhaps there is an elegant solution. + + bool operator==(const fixed_allocator_with_overflow& a, const fixed_allocator_with_overflow& b); + bool operator!=(const fixed_allocator_with_overflow& a, const fixed_allocator_with_overflow& b); + + + + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + inline bool operator==(const fixed_allocator&, const fixed_allocator&) + { + return false; + } + + inline bool operator!=(const fixed_allocator&, const fixed_allocator&) + { + return false; + } + + inline bool operator==(const fixed_allocator_with_overflow&, const fixed_allocator_with_overflow&) + { + return false; + } + + inline bool operator!=(const fixed_allocator_with_overflow&, const fixed_allocator_with_overflow&) + { + return false; + } + + +} // namespace eastl + + + + +#endif // Header include guard + + + diff --git a/lib/eastl/include/EASTL/fixed_hash_map.h b/lib/eastl/include/EASTL/fixed_hash_map.h new file mode 100644 index 0000000..4dc1a54 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_hash_map.h @@ -0,0 +1,419 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_hash_map.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a hash_map and hash_multimap which use a fixed size +// memory pool for its buckets and nodes. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_HASH_MAP_H +#define EASTL_FIXED_HASH_MAP_H + + +#include +#include + + +namespace eastl +{ + /// EASTL_FIXED_HASH_MAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_HASH_MAP_DEFAULT_NAME + #define EASTL_FIXED_HASH_MAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_hash_map" // Unless the user overrides something, this is "EASTL fixed_hash_map". + #endif + + #ifndef EASTL_FIXED_HASH_MULTIMAP_DEFAULT_NAME + #define EASTL_FIXED_HASH_MULTIMAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_hash_multimap" // Unless the user overrides something, this is "EASTL fixed_hash_multimap". + #endif + + + + /// fixed_hash_map + /// + /// Implements a hash_map with a fixed block of memory identified by the nodeCount and bucketCount + /// template parameters. + /// + /// Template parameters: + /// Key The key type for the map. This is a map of Key to T (value). + /// T The value type for the map. + /// nodeCount The max number of objects to contain. This value must be >= 1. + /// bucketCount The number of buckets to use. This value must be >= 2. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Hash hash_set hash function. See hash_set. + /// Predicate hash_set equality testing function. See hash_set. + /// + template , typename Predicate = eastl::equal_to, bool bCacheHashCode = false, typename Allocator = EASTLAllocatorType> + class fixed_hash_map : public hash_map::node_type), + nodeCount, + hash_map::kValueAlignment, + hash_map::kValueAlignmentOffset, + bEnableOverflow, + Allocator>, + bCacheHashCode> + { + public: + typedef fixed_hash_map this_type; + typedef fixed_hashtable_allocator::node_type), nodeCount, hash_map::kValueAlignment, hash_map::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef hash_map base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::mAllocator; + + protected: + node_type** mBucketBuffer[bucketCount + 1]; // '+1' because the hash table needs a null terminating bucket. + char mNodeBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + public: + /// fixed_hash_map + /// + /// Construct an empty fixed_hash_map with a given set of parameters. + /// + explicit fixed_hash_map(const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + } + + + /// fixed_hash_map + /// + /// Construct a fixed_hash_map from a source sequence and with a given set of parameters. + /// + template + fixed_hash_map(InputIterator first, InputIterator last, + const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(first, last); + } + + + /// fixed_hash_map + /// + /// Copy constructor + /// + fixed_hash_map(const this_type& x) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), x.hash_function(), + x.equal_function(), fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(x.begin(), x.end()); + } + + + /// operator= + /// + /// We provide an override so that assignment is done correctly. + /// + this_type& operator=(const this_type& x) + { + if(this != &x) + { + base_type::clear(); + base_type::insert(x.begin(), x.end()); + } + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mNodeBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_hash_map + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_hash_map& a, + fixed_hash_map& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + + + /// fixed_hash_multimap + /// + /// Implements a hash_multimap with a fixed block of memory identified by the nodeCount and bucketCount + /// template parameters. + /// + /// Template parameters: + /// Key The key type for the map. This is a map of Key to T (value). + /// T The value type for the map. + /// nodeCount The max number of objects to contain. This value must be >= 1. + /// bucketCount The number of buckets to use. This value must be >= 2. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Hash hash_set hash function. See hash_set. + /// Predicate hash_set equality testing function. See hash_set. + /// + template , typename Predicate = eastl::equal_to, bool bCacheHashCode = false, typename Allocator = EASTLAllocatorType> + class fixed_hash_multimap : public hash_multimap::node_type), + nodeCount, + hash_multimap::kValueAlignment, + hash_multimap::kValueAlignmentOffset, + bEnableOverflow, + Allocator>, + bCacheHashCode> + { + public: + typedef fixed_hash_multimap this_type; + typedef fixed_hashtable_allocator::node_type), nodeCount, hash_multimap::kValueAlignment, hash_multimap::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef hash_multimap base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::mAllocator; + + protected: + node_type** mBucketBuffer[bucketCount + 1]; // '+1' because the hash table needs a null terminating bucket. + char mNodeBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + public: + /// fixed_hash_multimap + /// + /// Construct an empty fixed_hash_multimap with a given set of parameters. + /// + explicit fixed_hash_multimap(const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MULTIMAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + } + + + /// fixed_hash_multimap + /// + /// Construct a fixed_hash_multimap from a source sequence and with a given set of parameters. + /// + template + fixed_hash_multimap(InputIterator first, InputIterator last, + const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MULTIMAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(first, last); + } + + + /// fixed_hash_multimap + /// + /// Copy constructor + /// + fixed_hash_multimap(const this_type& x) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), x.hash_function(), + x.equal_function(),fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(x.begin(), x.end()); + } + + + /// operator= + /// + /// We provide an override so that assignment is done correctly. + /// + this_type& operator=(const this_type& x) + { + if(this != &x) + { + base_type::clear(); + base_type::insert(x.begin(), x.end()); + } + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mNodeBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_hash_multimap + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_hash_multimap& a, + fixed_hash_multimap& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + +} // namespace eastl + + + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_hash_set.h b/lib/eastl/include/EASTL/fixed_hash_set.h new file mode 100644 index 0000000..6cd5a60 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_hash_set.h @@ -0,0 +1,422 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_hash_set.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a hash_set which uses a fixed size memory pool for +// its buckets and nodes. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_HASH_SET_H +#define EASTL_FIXED_HASH_SET_H + + +#include +#include + + + +namespace eastl +{ + /// EASTL_FIXED_HASH_SET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_HASH_SET_DEFAULT_NAME + #define EASTL_FIXED_HASH_SET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_hash_set" // Unless the user overrides something, this is "EASTL fixed_hash_set". + #endif + + #ifndef EASTL_FIXED_HASH_MULTISET_DEFAULT_NAME + #define EASTL_FIXED_HASH_MULTISET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_hash_multiset" // Unless the user overrides something, this is "EASTL fixed_hash_multiset". + #endif + + + + /// fixed_hash_set + /// + /// Implements a hash_set with a fixed block of memory identified by the nodeCount and bucketCount + /// template parameters. + /// + /// Template parameters: + /// Value The type of object the hash_set holds. + /// nodeCount The max number of objects to contain. This value must be >= 1. + /// bucketCount The number of buckets to use. This value must be >= 2. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Hash hash_set hash function. See hash_set. + /// Predicate hash_set equality testing function. See hash_set. + /// + template , typename Predicate = eastl::equal_to, bool bCacheHashCode = false, typename Allocator = EASTLAllocatorType> + class fixed_hash_set : public hash_set::node_type), + nodeCount, + hash_set::kValueAlignment, + hash_set::kValueAlignmentOffset, + bEnableOverflow, + Allocator>, + bCacheHashCode> + { + public: + typedef fixed_hash_set this_type; + typedef fixed_hashtable_allocator::node_type), nodeCount, hash_set::kValueAlignment, hash_set::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef hash_set base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::mAllocator; + + protected: + node_type** mBucketBuffer[bucketCount + 1]; // '+1' because the hash table needs a null terminating bucket. + char mNodeBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + public: + /// fixed_hash_set + /// + /// Construct an empty fixed_hash_set with a given set of parameters. + /// + explicit fixed_hash_set(const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), + hashFunction, predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_SET_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + } + + + /// fixed_hash_set + /// + /// Construct a fixed_hash_set from a source sequence and with a given set of parameters. + /// + template + fixed_hash_set(InputIterator first, InputIterator last, + const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_SET_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(first, last); + } + + + /// fixed_hash_set + /// + /// Copy constructor + /// + fixed_hash_set(const this_type& x) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), x.hash_function(), + x.equal_function(), fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(x.begin(), x.end()); + } + + + /// operator= + /// + /// We provide an override so that assignment is done correctly. + /// + this_type& operator=(const this_type& x) + { + if(this != &x) + { + base_type::clear(); + base_type::insert(x.begin(), x.end()); + } + return *this; + } + + + void swap(this_type& x) + { + // We must do a brute-force swap, because fixed containers cannot share memory allocations. + // Note that we create a temp value on the stack. This approach may fail if the size of the + // container is too large. We have a rule against allocating memory from the heap, and so + // if the user wants to swap two large objects of this class, the user will currently need + // to implement it manually. To consider: add code to allocate a temporary buffer if the + // size of the container is too large for the stack. + EASTL_ASSERT(sizeof(x) < EASTL_MAX_STACK_USAGE); // It is dangerous to try to create objects that are too big for the stack. + + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mNodeBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_hash_set + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_hash_set& a, + fixed_hash_set& b) + { + a.swap(b); + } + + + + + + + /// fixed_hash_multiset + /// + /// Implements a hash_multiset with a fixed block of memory identified by the nodeCount and bucketCount + /// template parameters. + /// + /// Value The type of object the hash_set holds. + /// nodeCount The max number of objects to contain. This value must be >= 1. + /// bucketCount The number of buckets to use. This value must be >= 2. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Hash hash_set hash function. See hash_set. + /// Predicate hash_set equality testing function. See hash_set. + /// + template , typename Predicate = eastl::equal_to, bool bCacheHashCode = false, typename Allocator = EASTLAllocatorType> + class fixed_hash_multiset : public hash_multiset::node_type), + nodeCount, + hash_multiset::kValueAlignment, + hash_multiset::kValueAlignmentOffset, + bEnableOverflow, + Allocator>, + bCacheHashCode> + { + public: + typedef fixed_hash_multiset this_type; + typedef fixed_hashtable_allocator::node_type), nodeCount, hash_multiset::kValueAlignment, hash_multiset::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef hash_multiset base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::mAllocator; + + protected: + node_type** mBucketBuffer[bucketCount + 1]; // '+1' because the hash table needs a null terminating bucket. + char mNodeBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + public: + /// fixed_hash_multiset + /// + /// Construct an empty fixed_hash_multiset with a given set of parameters. + /// + explicit fixed_hash_multiset(const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MULTISET_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + } + + + /// fixed_hash_multiset + /// + /// Construct a fixed_hash_multiset from a source sequence and with a given set of parameters. + /// + template + fixed_hash_multiset(InputIterator first, InputIterator last, + const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate()) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), hashFunction, + predicate, fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_HASH_MULTISET_DEFAULT_NAME); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(first, last); + } + + + /// fixed_hash_multiset + /// + /// Copy constructor + /// + fixed_hash_multiset(const this_type& x) + : base_type(prime_rehash_policy::GetPrevBucketCountOnly(bucketCount), x.hash_function(), + x.equal_function(), fixed_allocator_type(NULL, mBucketBuffer)) + { + EASTL_CT_ASSERT((nodeCount >= 1) && (bucketCount >= 2)); + base_type::set_max_load_factor(10000.f); // Set it so that we will never resize. + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mNodeBuffer); + base_type::insert(x.begin(), x.end()); + } + + + /// operator= + /// + /// We provide an override so that assignment is done correctly. + /// + this_type& operator=(const this_type& x) + { + if(this != &x) + { + base_type::clear(); + base_type::insert(x.begin(), x.end()); + } + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mNodeBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_hash_multiset + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_hash_multiset& a, + fixed_hash_multiset& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_list.h b/lib/eastl/include/EASTL/fixed_list.h new file mode 100644 index 0000000..a8a6f72 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_list.h @@ -0,0 +1,342 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_list.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a list which uses a fixed size memory pool for its nodes. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_LIST_H +#define EASTL_FIXED_LIST_H + + +#include +#include +#include + + +namespace eastl +{ + /// EASTL_FIXED_LIST_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_LIST_DEFAULT_NAME + #define EASTL_FIXED_LIST_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_list" // Unless the user overrides something, this is "EASTL fixed_list". + #endif + + + + /// fixed_list + /// + /// fixed_list is a list which uses a single block of contiguous memory + /// for its nodes. The purpose of this is to reduce memory usage relative + /// to a conventional memory allocation system (with block headers), to + /// increase allocation speed (often due to avoidance of mutex locks), + /// to increase performance (due to better memory locality), and to decrease + /// memory fragmentation due to the way that fixed block allocators work. + /// + /// The primary downside to a fixed_list is that the number of nodes it + /// can contain is fixed upon its declaration. If you want a fixed_list + /// that doesn't have this limitation, then you probably don't want a + /// fixed_list. You can always create your own memory allocator that works + /// the way you want. + /// + /// Template parameters: + /// T The type of object the list holds. + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template + class fixed_list : public list::node_type), + nodeCount, list::kAlignment, list::kAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_list this_type; + typedef fixed_node_allocator::node_type), nodeCount, + list::kAlignment, list::kAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef list base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::iterator iterator; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::assign; + using base_type::resize; + + protected: + char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + using base_type::mAllocator; + + public: + fixed_list(); + explicit fixed_list(size_type n); + fixed_list(size_type n, const value_type& value); + fixed_list(const this_type& x); + + template + fixed_list(InputIterator first, InputIterator last); + + this_type& operator=(const this_type& x); + + void swap(this_type& x); + void reset(); + size_type max_size() const; // Returns the max fixed size, which is the user-supplied nodeCount parameter. + bool has_overflowed() const; // Returns true if the fixed space is fully allocated. Note that if overflow is enabled, the container size can be greater than nodeCount but full() could return true because the fixed space may have a recently freed slot. + + template + void sort(Compare compare); + void sort(); + + template + void merge(this_type& x, Compare compare); + void merge(this_type& x); + + void splice(iterator position, this_type& x); + void splice(iterator position, this_type& x, iterator i); + void splice(iterator position, this_type& x, iterator first, iterator last); + + // Deprecated: + bool full() const { return has_overflowed(); } + + }; // fixed_list + + + + /////////////////////////////////////////////////////////////////////// + // fixed_list + /////////////////////////////////////////////////////////////////////// + + template + inline fixed_list::fixed_list() + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_LIST_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + template + inline fixed_list::fixed_list(size_type n) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_LIST_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + resize(n); + } + + + template + inline fixed_list::fixed_list(size_type n, const value_type& value) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_LIST_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + resize(n, value); + } + + + template + inline fixed_list::fixed_list(const this_type& x) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mBuffer); + assign(x.begin(), x.end()); + } + + + template + template + fixed_list::fixed_list(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_LIST_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + assign(first, last); + } + + + template + inline typename fixed_list::this_type& + fixed_list::operator=(const this_type& x) + { + if(this != &x) + { + base_type::clear(); + + #if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; + #endif + + base_type::assign(x.begin(), x.end()); // It would probably be better to implement this like list::operator=. + } + return *this; + } + + + template + inline void fixed_list::swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + template + inline void fixed_list::reset() + { + base_type::reset(); + base_type::get_allocator().reset(mBuffer); + } + + + template + inline typename fixed_list::size_type + fixed_list::max_size() const + { + return kMaxSize; + } + + + template + inline bool fixed_list::has_overflowed() const + { + return !mAllocator.can_allocate(); + } + + + template + inline void fixed_list::sort() + { + eastl::insertion_sort(base_type::begin(), base_type::end()); + } + + + template + template + inline void fixed_list::sort(Compare compare) + { + eastl::insertion_sort(base_type::begin(), base_type::end(), compare); + } + + + template + void fixed_list::merge(this_type& /*x*/) + { + // To do. + } + + template + template + void fixed_list::merge(this_type& /*x*/, Compare /*compare*/) + { + // To do. + } + + template + void fixed_list::splice(iterator /*position*/, this_type& /*x*/) + { + // To do. + } + + template + void fixed_list::splice(iterator /*position*/, this_type& /*x*/, iterator /*i*/) + { + // To do. + } + + template + void fixed_list::splice(iterator /*position*/, this_type& /*x*/, iterator /*first*/, iterator /*last*/) + { + // To do. + } + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_list& a, + fixed_list& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_map.h b/lib/eastl/include/EASTL/fixed_map.h new file mode 100644 index 0000000..75a83c6 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_map.h @@ -0,0 +1,358 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_map.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a map and multimap which use a fixed size memory +// pool for their nodes. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_MAP_H +#define EASTL_FIXED_MAP_H + + +#include +#include // Included because fixed_rbtree_base resides here. + + +namespace eastl +{ + /// EASTL_FIXED_MAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_MAP_DEFAULT_NAME + #define EASTL_FIXED_MAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_map" // Unless the user overrides something, this is "EASTL fixed_map". + #endif + + #ifndef EASTL_FIXED_MULTIMAP_DEFAULT_NAME + #define EASTL_FIXED_MULTIMAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_multimap" // Unless the user overrides something, this is "EASTL fixed_multimap". + #endif + + + + /// fixed_map + /// + /// Implements a map with a fixed block of memory identified by the + /// nodeCount template parameter. + /// + /// Key The key object (key in the key/value pair). + /// T The mapped object (value in the key/value pair). + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Compare Compare function/object for set ordering. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template , typename Allocator = EASTLAllocatorType> + class fixed_map : public map::node_type), + nodeCount, map::kValueAlignment, map::kValueAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_map this_type; + typedef fixed_node_allocator::node_type), nodeCount, + map::kValueAlignment, map::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef map base_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::insert; + + protected: + char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + using base_type::mAllocator; + + public: + /// fixed_map + /// + fixed_map() + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_map + /// + explicit fixed_map(const Compare& compare) + : base_type(compare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_map + /// + fixed_map(const this_type& x) + : base_type(x.mCompare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mBuffer); + base_type::operator=(x); + } + + + /// fixed_map + /// + template + fixed_map(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + insert(first, last); + } + + + /// operator= + /// + this_type& operator=(const this_type& x) + { + base_type::operator=(x); + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_map + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_map& a, + fixed_map& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + + + + /// fixed_multimap + /// + /// Implements a multimap with a fixed block of memory identified by the + /// nodeCount template parameter. + /// + /// Key The key object (key in the key/value pair). + /// T The mapped object (value in the key/value pair). + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Compare Compare function/object for set ordering. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template , typename Allocator = EASTLAllocatorType> + class fixed_multimap : public multimap::node_type), + nodeCount, multimap::kValueAlignment, multimap::kValueAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_multimap this_type; + typedef fixed_node_allocator::node_type), nodeCount, + multimap::kValueAlignment, multimap::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef multimap base_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::insert; + + protected: + char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + using base_type::mAllocator; + + public: + /// fixed_multimap + /// + fixed_multimap() + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTIMAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_multimap + /// + explicit fixed_multimap(const Compare& compare) + : base_type(compare, fixed_allocator_type(mBuffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTIMAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_multimap + /// + fixed_multimap(const this_type& x) + : base_type(x.mCompare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mBuffer); + base_type::operator=(x); + } + + + /// fixed_multimap + /// + template + fixed_multimap(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTIMAP_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + insert(first, last); + } + + + /// operator= + /// + this_type& operator=(const this_type& x) + { + base_type::operator=(x); + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_multimap + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_multimap& a, + fixed_multimap& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_set.h b/lib/eastl/include/EASTL/fixed_set.h new file mode 100644 index 0000000..de676fb --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_set.h @@ -0,0 +1,360 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_set.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a set and multiset which use a fixed size memory +// pool for their nodes. +// +/////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_FIXED_SET_H +#define EASTL_FIXED_SET_H + + +#include +#include + + +namespace eastl +{ + /// EASTL_FIXED_SET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_SET_DEFAULT_NAME + #define EASTL_FIXED_SET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_set" // Unless the user overrides something, this is "EASTL fixed_set". + #endif + + #ifndef EASTL_FIXED_MULTISET_DEFAULT_NAME + #define EASTL_FIXED_MULTISET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_multiset" // Unless the user overrides something, this is "EASTL fixed_multiset". + #endif + + + + /// fixed_set + /// + /// Implements a set with a fixed block of memory identified by the + /// nodeCount template parameter. + /// + /// Template parameters: + /// Key The type of object the set holds (a.k.a. value). + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Compare Compare function/object for set ordering. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template , typename Allocator = EASTLAllocatorType> + class fixed_set : public set::node_type), + nodeCount, set::kValueAlignment, set::kValueAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_set this_type; + typedef fixed_node_allocator::node_type), nodeCount, + set::kValueAlignment, set::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef set base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::insert; + + protected: + char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + using base_type::mAllocator; + + public: + /// fixed_set + /// + fixed_set() + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_set + /// + explicit fixed_set(const Compare& compare) + : base_type(compare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_set + /// + fixed_set(const this_type& x) + : base_type(x.mCompare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mBuffer); + base_type::operator=(x); + } + + + /// fixed_set + /// + template + fixed_set(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + insert(first, last); + } + + + /// operator= + /// + this_type& operator=(const this_type& x) + { + base_type::operator=(x); + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_set + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_set& a, + fixed_set& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + + + + + + + /// fixed_multiset + /// + /// Implements a multiset with a fixed block of memory identified by the + /// nodeCount template parameter. + /// + /// Key The type of object the set holds (a.k.a. value). + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the global heap if our object pool is exhausted. + /// Compare Compare function/object for set ordering. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template , typename Allocator = EASTLAllocatorType> + class fixed_multiset : public multiset::node_type), + nodeCount, multiset::kValueAlignment, multiset::kValueAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_multiset this_type; + typedef fixed_node_allocator::node_type), nodeCount, + multiset::kValueAlignment, multiset::kValueAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef multiset base_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::size_type size_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::insert; + + protected: + char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements. + + using base_type::mAllocator; + + public: + /// fixed_multiset + /// + fixed_multiset() + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_multiset + /// + explicit fixed_multiset(const Compare& compare) + : base_type(compare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + } + + + /// fixed_multiset + /// + fixed_multiset(const this_type& x) + : base_type(x.mCompare, fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mAllocator.reset(mBuffer); + base_type::operator=(x); + } + + + /// fixed_multiset + /// + template + fixed_multiset(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(NULL)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME); + #endif + + mAllocator.reset(mBuffer); + insert(first, last); + } + + + /// operator= + /// + this_type& operator=(const this_type& x) + { + base_type::operator=(x); + return *this; + } + + + void swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + void reset() + { + base_type::reset(); + base_type::get_allocator().reset(mBuffer); + } + + + size_type max_size() const + { + return kMaxSize; + } + + }; // fixed_multiset + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline void swap(fixed_multiset& a, + fixed_multiset& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_string.h b/lib/eastl/include/EASTL/fixed_string.h new file mode 100644 index 0000000..54cd90a --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_string.h @@ -0,0 +1,539 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_string.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a string which uses a fixed size memory pool. +// The bEnableOverflow template parameter allows the container to resort to +// heap allocations if the memory pool is exhausted. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_STRING_H +#define EASTL_FIXED_STRING_H + + +#include +#if EASTL_ABSTRACT_STRING_ENABLED + #include +#else // 'else' encompasses the entire rest of this file. +#include +#include + + + +namespace eastl +{ + /// EASTL_FIXED_STRING_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_STRING_DEFAULT_NAME + #define EASTL_FIXED_STRING_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_string" // Unless the user overrides something, this is "EASTL fixed_string". + #endif + + + + /// fixed_string + /// + /// A fixed_string with bEnableOverflow == true is identical to a regular + /// string in terms of its behavior. All the expectations of regular string + /// apply to it and no additional expectations come from it. When bEnableOverflow + /// is false, fixed_string behaves like regular string with the exception that + /// its capacity can never increase. All operations you do on such a fixed_string + /// which require a capacity increase will result in undefined behavior or an + /// C++ allocation exception, depending on the configuration of EASTL. + /// + /// Note: The nodeCount value is the amount of characters to allocate, which needs to + /// take into account a terminating zero. Thus if you want to store strings with a strlen + /// of 30, the nodeCount value must be at least 31. + /// + /// Template parameters: + /// T The type of object the string holds (char, wchar_t, char8_t, char16_t, char32_t). + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + /// Notes: + /// The nodeCount value must be at least 2, one for a character and one for a terminating 0. + /// + /// As of this writing, the string class necessarily reallocates when an insert of + /// self is done into self. As a result, the fixed_string class doesn't support + /// inserting self into self unless the bEnableOverflow template parameter is true. + /// + /// Example usage: + /// fixed_string fixedString("hello world"); // Can hold up to a strlen of 128. + /// + /// fixedString = "hola mundo"; + /// fixedString.clear(); + /// fixedString.resize(200); + /// fixedString.sprintf("%f", 1.5f); + /// + template + class fixed_string : public basic_string::kAlignment, basic_string::kAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_vector_allocator::kAlignment, + basic_string::kAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef typename fixed_allocator_type::overflow_allocator_type overflow_allocator_type; + typedef basic_string base_type; + typedef fixed_string this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::CtorDoNotInitialize CtorDoNotInitialize; + typedef typename base_type::CtorSprintf CtorSprintf; + typedef aligned_buffer::kAlignment> aligned_buffer_type; + + enum + { + kMaxSize = nodeCount - 1 // -1 because we need to save one element for the silent terminating null. + }; + + using base_type::mAllocator; + using base_type::npos; + using base_type::mpBegin; + using base_type::mpEnd; + using base_type::mpCapacity; + using base_type::append; + using base_type::resize; + using base_type::clear; + using base_type::size; + using base_type::sprintf_va_list; + + protected: + union // We define a union in order to avoid strict pointer aliasing issues with compilers like GCC. + { + value_type mArray[1]; + aligned_buffer_type mBuffer; // Question: Why are we doing this aligned_buffer thing? Why not just do an array of value_type, given that we are using just strings of char types. + }; + + public: + fixed_string(); + fixed_string(const base_type& x, size_type position, size_type n = base_type::npos); + fixed_string(const value_type* p, size_type n); + fixed_string(const value_type* p); + fixed_string(size_type n, const value_type& value); + fixed_string(const this_type& x); + fixed_string(const base_type& x); + fixed_string(const value_type* pBegin, const value_type* pEnd); + fixed_string(CtorDoNotInitialize, size_type n); + fixed_string(CtorSprintf, const value_type* pFormat, ...); + + this_type& operator=(const this_type& x); + this_type& operator=(const base_type& x); + this_type& operator=(const value_type* p); + this_type& operator=(const value_type c); + + void swap(this_type& x); + + void set_capacity(size_type n); + void reset(); + size_type max_size() const; + + // The inherited versions of substr/left/right call the basic_string constructor, + // which will call the overflow allocator and fail if bEnableOverflow == false + this_type substr(size_type position, size_type n) const; + this_type left(size_type n) const; + this_type right(size_type n) const; + + // Allocator + overflow_allocator_type& get_overflow_allocator(); + void set_overflow_allocator(const overflow_allocator_type& allocator); + + }; // fixed_string + + + + + + /////////////////////////////////////////////////////////////////////// + // fixed_string + /////////////////////////////////////////////////////////////////////// + + template + inline fixed_string:: + fixed_string() + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + } + + + template + inline fixed_string:: + fixed_string(const this_type& x) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + append(x); + } + + + template + inline fixed_string:: + fixed_string(const base_type& x) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.get_allocator().get_name()); + #endif + + append(x); + } + + + template + inline fixed_string:: + fixed_string(const base_type& x, size_type position, size_type n) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.get_allocator().get_name()); + #endif + + append(x, position, n); + } + + + template + inline fixed_string:: + fixed_string(const value_type* p, size_type n) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + append(p, n); + } + + + template + inline fixed_string:: + fixed_string(const value_type* p) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + append(p); // There better be enough space to hold the assigned string. + } + + + template + inline fixed_string:: + fixed_string(size_type n, const value_type& value) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + append(n, value); // There better be enough space to hold the assigned string. + } + + + template + inline fixed_string:: + fixed_string(const value_type* pBegin, const value_type* pEnd) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + append(pBegin, pEnd); + } + + + template + inline fixed_string:: + fixed_string(CtorDoNotInitialize, size_type n) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + mpBegin = mArray; + mpCapacity = mpBegin + nodeCount; + + if((mpBegin + n) < mpCapacity) + { + mpEnd = mpBegin + n; + *mpEnd = 0; + } + else + { + mpEnd = mArray; + *mpEnd = 0; + resize(n); + } + } + + + template + inline fixed_string:: + fixed_string(CtorSprintf, const value_type* pFormat, ...) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + *mpBegin = 0; + + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_STRING_DEFAULT_NAME); + #endif + + va_list arguments; + va_start(arguments, pFormat); + sprintf_va_list(pFormat, arguments); + va_end(arguments); + } + + + template + inline typename fixed_string::this_type& + fixed_string::operator=(const this_type& x) + { + if(this != &x) + { + clear(); + append(x); + } + return *this; + } + + + template + inline typename fixed_string:: + this_type& fixed_string::operator=(const base_type& x) + { + if(static_cast(this) != &x) + { + clear(); + append(x); + } + return *this; + } + + + template + inline typename fixed_string:: + this_type& fixed_string::operator=(const value_type* p) + { + if(mpBegin != p) + { + clear(); + append(p); + } + return *this; + } + + + template + inline typename fixed_string:: + this_type& fixed_string::operator=(const value_type c) + { + clear(); + append((size_type)1, c); + return *this; + } + + + template + inline void fixed_string:: + swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + template + inline void fixed_string:: + set_capacity(size_type n) + { + // We act consistently with vector::set_capacity and reduce our + // size if the new capacity is smaller than our size. + if(n < size()) + resize(n); + // To consider: If bEnableOverflow is true, then perhaps we should + // switch to the overflow allocator and set the capacity. + } + + + template + inline void fixed_string:: + reset() + { + mpBegin = mpEnd = mArray; + mpCapacity = mpBegin + nodeCount; + } + + + template + inline typename fixed_string:: + size_type fixed_string::max_size() const + { + return kMaxSize; + } + + + template + inline typename fixed_string:: + this_type fixed_string::substr(size_type position, size_type n) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(position > (size_type)(mpEnd - mpBegin)) + ThrowRangeException(); + #endif + + return fixed_string(mpBegin + position, mpBegin + position + eastl::min_alt(n, (size_type)(mpEnd - mpBegin) - position)); + } + + + template + inline typename fixed_string:: + this_type fixed_string::left(size_type n) const + { + const size_type nLength = size(); + if(n < nLength) + return fixed_string(mpBegin, mpBegin + n); + return *this; + } + + + template + inline typename fixed_string:: + this_type fixed_string::right(size_type n) const + { + const size_type nLength = size(); + if(n < nLength) + return fixed_string(mpEnd - n, mpEnd); + return *this; + } + + + template + inline typename fixed_string:: + overflow_allocator_type& fixed_string::get_overflow_allocator() + { + return mAllocator.get_overflow_allocator(); + } + + + template + inline void + fixed_string::set_overflow_allocator(const overflow_allocator_type& allocator) + { + mAllocator.set_overflow_allocator(allocator); + } + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + // operator ==, !=, <, >, <=, >= come from the string implementations. + + template + inline void swap(fixed_string& a, + fixed_string& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + +} // namespace eastl + + +#endif // EASTL_ABSTRACT_STRING_ENABLED + +#endif // Header include guard + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_substring.h b/lib/eastl/include/EASTL/fixed_substring.h new file mode 100644 index 0000000..be40d37 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_substring.h @@ -0,0 +1,300 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_substring.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_SUBSTRING_H +#define EASTL_FIXED_SUBSTRING_H + + +#include + + +namespace eastl +{ + + /// fixed_substring + /// + /// Implements a string which is a reference to a segment of characters. + /// This class is efficient because it allocates no memory and copies no + /// memory during construction and assignment, but rather refers directly + /// to the segment of chracters. A common use of this is to have a + /// fixed_substring efficiently refer to a substring within another string. + /// + /// You cannot directly resize a fixed_substring (e.g. via resize, insert, + /// append, erase), but you can assign a different substring to it. + /// You can modify the characters within a substring in place. + /// As of this writing, in the name of being lean and simple it is the + /// user's responsibility to not call unsupported resizing functions + /// such as those listed above. A detailed listing of the functions which + /// are not supported is given below in the class declaration. + /// + /// The c_str function doesn't act as one might hope, as it simply + /// returns the pointer to the beginning of the string segment and the + /// 0-terminator may be beyond the end of the segment. If you want to + /// always be able to use c_str as expected, use the fixed string solution + /// we describe below. + /// + /// Another use of fixed_substring is to provide C++ string-like functionality + /// with a C character array. This allows you to work on a C character array + /// as if it were a C++ string as opposed using the C string API. Thus you + /// can do this: + /// + /// void DoSomethingForUser(char* timeStr, size_t timeStrCapacity) + /// { + /// fixed_substring tmp(timeStr, timeStrCapacity); + /// tmp = "hello "; + /// tmp += "world"; + /// } + /// + /// Note that this class constructs and assigns from const string pointers + /// and const string objects, yet this class does not declare its member + /// data as const. This is a concession in order to allow this implementation + /// to be simple and lean. It is the user's responsibility to make sure + /// that strings that should not or can not be modified are either not + /// used by fixed_substring or are not modified by fixed_substring. + /// + /// A more flexible alternative to fixed_substring is fixed_string. + /// fixed_string has none of the functional limitations that fixed_substring + /// has and like fixed_substring it doesn't allocate memory. However, + /// fixed_string makes a *copy* of the source string and uses local + /// memory to store that copy. Also, fixed_string objects on the stack + /// are going to have a limit as to their maximum size. + /// + /// Notes: + /// As of this writing, the string class necessarily reallocates when + /// an insert of self is done into self. As a result, the fixed_substring + /// class doesn't support inserting self into self. + /// + /// Example usage: + /// basic_string str("hello world"); + /// fixed_substring sub(str, 2, 5); // sub == "llo w" + /// + template + class fixed_substring : public basic_string + { + public: + typedef basic_string base_type; + typedef fixed_substring this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + + using base_type::npos; + using base_type::mpBegin; + using base_type::mpEnd; + using base_type::mpCapacity; + using base_type::reset; + using base_type::mAllocator; + + public: + fixed_substring() + : base_type() + { + } + + fixed_substring(const base_type& x) + : base_type() + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.get_allocator().get_name()); + #endif + + assign(x); + } + + fixed_substring(const base_type& x, size_type position, size_type n = base_type::npos) + : base_type() + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.get_allocator().get_name()); + #endif + + assign(x, position, n); + } + + fixed_substring(const value_type* p, size_type n) + : base_type() + { + assign(p, n); + } + + fixed_substring(const value_type* p) + : base_type() + { + assign(p); + } + + fixed_substring(const value_type* pBegin, const value_type* pEnd) + : base_type() + { + assign(pBegin, pEnd); + } + + ~fixed_substring() + { + // We need to reset, as otherwise the parent destructor will + // attempt to free our memory. + reset(); + } + + this_type& operator=(const base_type& x) + { + assign(x); + return *this; + } + + this_type& operator=(const value_type* p) + { + assign(p); + return *this; + } + + this_type& assign(const base_type& x) + { + // By design, we need to cast away const-ness here. + mpBegin = const_cast(x.data()); + mpEnd = mpBegin + x.size(); + mpCapacity = mpEnd; + return *this; + } + + this_type& assign(const base_type& x, size_type position, size_type n) + { + // By design, we need to cast away const-ness here. + mpBegin = const_cast(x.data()) + position; + mpEnd = mpBegin + n; + mpCapacity = mpEnd; + return *this; + } + + this_type& assign(const value_type* p, size_type n) + { + // By design, we need to cast away const-ness here. + mpBegin = const_cast(p); + mpEnd = mpBegin + n; + mpCapacity = mpEnd; + return *this; + } + + this_type& assign(const value_type* p) + { + // By design, we need to cast away const-ness here. + mpBegin = const_cast(p); + mpEnd = mpBegin + CharStrlen(p); + mpCapacity = mpEnd; + return *this; + } + + this_type& assign(const value_type* pBegin, const value_type* pEnd) + { + // By design, we need to cast away const-ness here. + mpBegin = const_cast(pBegin); + mpEnd = const_cast(pEnd); + mpCapacity = mpEnd; + return *this; + } + + + // Partially supported functionality + // + // When using fixed_substring on a character sequence that is within another + // string, the following functions may do one of two things: + // 1 Attempt to reallocate + // 2 Write a 0 char at the end of the fixed_substring + // + // Item #1 will result in a crash, due to the attempt by the underlying + // string class to free the substring memory. Item #2 will result in a 0 + // char being written to the character array. Item #2 may or may not be + // a problem, depending on how you use fixed_substring. Thus the following + // functions should be used carefully. + // + // basic_string& operator=(const basic_string& x); + // basic_string& operator=(value_type c); + // void resize(size_type n, value_type c); + // void resize(size_type n); + // void reserve(size_type = 0); + // void set_capacity(size_type n); + // void clear(); + // basic_string& operator+=(const basic_string& x); + // basic_string& operator+=(const value_type* p); + // basic_string& operator+=(value_type c); + // basic_string& append(const basic_string& x); + // basic_string& append(const basic_string& x, size_type position, size_type n); + // basic_string& append(const value_type* p, size_type n); + // basic_string& append(const value_type* p); + // basic_string& append(size_type n); + // basic_string& append(size_type n, value_type c); + // basic_string& append(const value_type* pBegin, const value_type* pEnd); + // basic_string& append_sprintf_va_list(const value_type* pFormat, va_list arguments); + // basic_string& append_sprintf(const value_type* pFormat, ...); + // void push_back(value_type c); + // void pop_back(); + // basic_string& assign(const value_type* p, size_type n); + // basic_string& assign(size_type n, value_type c); + // basic_string& insert(size_type position, const basic_string& x); + // basic_string& insert(size_type position, const basic_string& x, size_type beg, size_type n); + // basic_string& insert(size_type position, const value_type* p, size_type n); + // basic_string& insert(size_type position, const value_type* p); + // basic_string& insert(size_type position, size_type n, value_type c); + // iterator insert(iterator p, value_type c); + // void insert(iterator p, size_type n, value_type c); + // void insert(iterator p, const value_type* pBegin, const value_type* pEnd); + // basic_string& erase(size_type position = 0, size_type n = npos); + // iterator erase(iterator p); + // iterator erase(iterator pBegin, iterator pEnd); + // void swap(basic_string& x); + // basic_string& sprintf_va_list(const value_type* pFormat, va_list arguments); + // basic_string& sprintf(const value_type* pFormat, ...); + + + }; // fixed_substring + + +} // namespace eastl + + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/fixed_vector.h b/lib/eastl/include/EASTL/fixed_vector.h new file mode 100644 index 0000000..39687e8 --- /dev/null +++ b/lib/eastl/include/EASTL/fixed_vector.h @@ -0,0 +1,333 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_vector.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a vector which uses a fixed size memory pool. +// The bEnableOverflow template parameter allows the container to resort to +// heap allocations if the memory pool is exhausted. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FIXED_VECTOR_H +#define EASTL_FIXED_VECTOR_H + + +#include +#include + + +namespace eastl +{ + /// EASTL_FIXED_VECTOR_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// In the case of fixed-size containers, the allocator name always refers + /// to overflow allocations. + /// + #ifndef EASTL_FIXED_VECTOR_DEFAULT_NAME + #define EASTL_FIXED_VECTOR_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_vector" // Unless the user overrides something, this is "EASTL fixed_vector". + #endif + + + /// fixed_vector + /// + /// A fixed_vector with bEnableOverflow == true is identical to a regular + /// vector in terms of its behavior. All the expectations of regular vector + /// apply to it and no additional expectations come from it. When bEnableOverflow + /// is false, fixed_vector behaves like regular vector with the exception that + /// its capacity can never increase. All operations you do on such a fixed_vector + /// which require a capacity increase will result in undefined behavior or an + /// C++ allocation exception, depending on the configuration of EASTL. + /// + /// Template parameters: + /// T The type of object the vector holds. + /// nodeCount The max number of objects to contain. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + /// Note: The nodeCount value must be at least 1. + /// + /// Example usage: + /// fixed_vector fixedVector); + /// + /// fixedVector.push_back(Widget()); + /// fixedVector.resize(200); + /// fixedVector.clear(); + /// + template + class fixed_vector : public vector::kAlignment, vector::kAlignmentOffset, bEnableOverflow, Allocator> > + { + public: + typedef fixed_vector_allocator::kAlignment, + vector::kAlignmentOffset, bEnableOverflow, Allocator> fixed_allocator_type; + typedef vector base_type; + typedef fixed_vector this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef aligned_buffer::kAlignment> aligned_buffer_type; + + enum + { + kMaxSize = nodeCount + }; + + using base_type::mAllocator; + using base_type::mpBegin; + using base_type::mpEnd; + using base_type::mpCapacity; + using base_type::resize; + using base_type::clear; + using base_type::size; + using base_type::assign; + + protected: + aligned_buffer_type mBuffer; + + public: + fixed_vector(); + explicit fixed_vector(size_type n); + fixed_vector(size_type n, const value_type& value); + fixed_vector(const this_type& x); + + template + fixed_vector(InputIterator first, InputIterator last); + + this_type& operator=(const this_type& x); + + void swap(this_type& x); + + void set_capacity(size_type n); + void reset(); + size_type max_size() const; // Returns the max fixed size, which is the user-supplied nodeCount parameter. + bool has_overflowed() const; // Returns true if the fixed space is fully allocated. Note that if overflow is enabled, the container size can be greater than nodeCount but full() could return true because the fixed space may have a recently freed slot. + + void* push_back_uninitialized(); + + // Deprecated: + bool full() const { return has_overflowed(); } + + protected: + void* DoPushBackUninitialized(true_type); + void* DoPushBackUninitialized(false_type); + + }; // fixed_vector + + + + + /////////////////////////////////////////////////////////////////////// + // fixed_vector + /////////////////////////////////////////////////////////////////////// + + template + inline fixed_vector::fixed_vector() + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_VECTOR_DEFAULT_NAME); + #endif + + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + } + + template + inline fixed_vector::fixed_vector(size_type n) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_VECTOR_DEFAULT_NAME); + #endif + + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + resize(n); + } + + + template + inline fixed_vector::fixed_vector(size_type n, const value_type& value) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_VECTOR_DEFAULT_NAME); + #endif + + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + resize(n, value); + } + + + template + inline fixed_vector::fixed_vector(const this_type& x) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(x.mAllocator.get_name()); + #endif + + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + assign(x.begin(), x.end()); + } + + + template + template + fixed_vector::fixed_vector(InputIterator first, InputIterator last) + : base_type(fixed_allocator_type(mBuffer.buffer)) + { + #if EASTL_NAME_ENABLED + mAllocator.set_name(EASTL_FIXED_VECTOR_DEFAULT_NAME); + #endif + + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + //assign(first, last); // Metrowerks gets confused by this. + base_type::DoAssign(first, last, is_integral()); + } + + + template + inline typename fixed_vector::this_type& + fixed_vector::operator=(const this_type& x) + { + if(this != &x) + { + clear(); + assign(x.begin(), x.end()); + } + return *this; + } + + + template + inline void fixed_vector::swap(this_type& x) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(*this, x); + } + + + template + inline void fixed_vector::set_capacity(size_type n) + { + // We act consistently with vector::set_capacity and reduce our + // size if the new capacity is smaller than our size. + if(n < size()) + resize(n); + // To consider: If bEnableOverflow is true, then perhaps we should + // switch to the overflow allocator and set the capacity. + } + + + template + inline void fixed_vector::reset() + { + mpBegin = mpEnd = (value_type*)&mBuffer.buffer[0]; + mpCapacity = mpBegin + nodeCount; + } + + + template + inline typename fixed_vector::size_type + fixed_vector::max_size() const + { + return kMaxSize; + } + + + template + inline bool fixed_vector::has_overflowed() const + { + // If size >= capacity, then we are definitely full. + // Also, if our size is smaller but we've switched away from mBuffer due to a previous overflow, then we are considered full. + return ((size_t)(mpEnd - mpBegin) >= kMaxSize) || ((void*)mpBegin != (void*)mBuffer.buffer); + } + + + template + inline void* fixed_vector::push_back_uninitialized() + { + return DoPushBackUninitialized(typename type_select::type()); + } + + template + inline void* fixed_vector::DoPushBackUninitialized(true_type) + { + return base_type::push_back_uninitialized(); + } + + template + inline void* fixed_vector::DoPushBackUninitialized(false_type) + { + return mpEnd++; + } + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + // operator ==, !=, <, >, <=, >= come from the vector implementations. + + template + inline void swap(fixed_vector& a, + fixed_vector& b) + { + // Fixed containers use a special swap that can deal with excessively large buffers. + eastl::fixed_swap(a, b); + } + + + +} // namespace eastl + + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/functional.h b/lib/eastl/include/EASTL/functional.h new file mode 100644 index 0000000..14b7ad3 --- /dev/null +++ b/lib/eastl/include/EASTL/functional.h @@ -0,0 +1,936 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/functional.h +// Written and maintained by Paul Pedriana - 2005 +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_FUNCTIONAL_H +#define EASTL_FUNCTIONAL_H + + +#include +#include + + +namespace eastl +{ + + /////////////////////////////////////////////////////////////////////// + // Primary C++ functions + /////////////////////////////////////////////////////////////////////// + + template + struct unary_function + { + typedef Argument argument_type; + typedef Result result_type; + }; + + + template + struct binary_function + { + typedef Argument1 first_argument_type; + typedef Argument2 second_argument_type; + typedef Result result_type; + }; + + + template + struct plus : public binary_function + { + T operator()(const T& a, const T& b) const + { return a + b; } + }; + + template + struct minus : public binary_function + { + T operator()(const T& a, const T& b) const + { return a - b; } + }; + + template + struct multiplies : public binary_function + { + T operator()(const T& a, const T& b) const + { return a * b; } + }; + + template + struct divides : public binary_function + { + T operator()(const T& a, const T& b) const + { return a / b; } + }; + + template + struct modulus : public binary_function + { + T operator()(const T& a, const T& b) const + { return a % b; } + }; + + template + struct negate : public unary_function + { + T operator()(const T& a) const + { return -a; } + }; + + template + struct equal_to : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a == b; } + }; + + template + bool validate_equal_to(const T& a, const T& b, Compare compare) + { + return compare(a, b) == compare(b, a); + } + + template + struct not_equal_to : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a != b; } + }; + + template + bool validate_not_equal_to(const T& a, const T& b, Compare compare) + { + return compare(a, b) == compare(b, a); // We want the not equal comparison results to be equal. + } + + /// str_equal_to + /// + /// Compares two 0-terminated string types. + /// The T types are expected to be iterators or act like iterators. + /// + /// Example usage: + /// hash_set, str_equal_to > stringHashSet; + /// + /// Note: + /// You couldn't use str_equal_to like this: + /// bool result = equal("hi", "hi" + 2, "ho", str_equal_to()); + /// This is because equal tests an array of something, with each element by + /// the comparison function. But str_equal_to tests an array of something itself. + /// + template + struct str_equal_to : public binary_function + { + bool operator()(T a, T b) const + { + while(*a && (*a == *b)) + { + ++a; + ++b; + } + return (*a == *b); + } + }; + + template + struct greater : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a > b; } + }; + + template + bool validate_greater(const T& a, const T& b, Compare compare) + { + return !compare(a, b) || !compare(b, a); // If (a > b), then !(b > a) + } + + template + struct less : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a < b; } + }; + + template + bool validate_less(const T& a, const T& b, Compare compare) + { + return !compare(a, b) || !compare(b, a); // If (a < b), then !(b < a) + } + + template + struct greater_equal : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a >= b; } + }; + + template + bool validate_greater_equal(const T& a, const T& b, Compare compare) + { + return !compare(a, b) || !compare(b, a); // If (a >= b), then !(b >= a) + } + + template + struct less_equal : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a <= b; } + }; + + template + bool validate_less_equal(const T& a, const T& b, Compare compare) + { + return !compare(a, b) || !compare(b, a); // If (a <= b), then !(b <= a) + } + + template + struct logical_and : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a && b; } + }; + + template + struct logical_or : public binary_function + { + bool operator()(const T& a, const T& b) const + { return a || b; } + }; + + template + struct logical_not : public unary_function + { + bool operator()(const T& a) const + { return !a; } + }; + + + + /////////////////////////////////////////////////////////////////////// + // Dual type functions + /////////////////////////////////////////////////////////////////////// + + template + struct equal_to_2 : public binary_function + { + bool operator()(const T& a, const U& b) const + { return a == b; } + }; + + template + struct not_equal_to_2 : public binary_function + { + bool operator()(const T& a, const U& b) const + { return a != b; } + }; + + template + struct less_2 : public binary_function + { + bool operator()(const T& a, const U& b) const + { return a < b; } + }; + + + + + /// unary_negate + /// + template + class unary_negate : public unary_function + { + protected: + Predicate mPredicate; + public: + explicit unary_negate(const Predicate& a) + : mPredicate(a) {} + bool operator()(const typename Predicate::argument_type& a) const + { return !mPredicate(a); } + }; + + template + inline unary_negate not1(const Predicate& predicate) + { return unary_negate(predicate); } + + + + /// binary_negate + /// + template + class binary_negate : public binary_function + { + protected: + Predicate mPredicate; + public: + explicit binary_negate(const Predicate& a) + : mPredicate(a) { } + bool operator()(const typename Predicate::first_argument_type& a, const typename Predicate::second_argument_type& b) const + { return !mPredicate(a, b); } + }; + + template + inline binary_negate not2(const Predicate& predicate) + { return binary_negate(predicate); } + + + + + /////////////////////////////////////////////////////////////////////// + // bind + /////////////////////////////////////////////////////////////////////// + + /// bind1st + /// + template + class binder1st : public unary_function + { + protected: + typename Operation::first_argument_type value; + Operation op; + + public: + binder1st(const Operation& x, const typename Operation::first_argument_type& y) + : value(y), op(x) { } + + typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const + { return op(value, x); } + + typename Operation::result_type operator()(typename Operation::second_argument_type& x) const + { return op(value, x); } + }; + + + template + inline binder1st bind1st(const Operation& op, const T& x) + { + typedef typename Operation::first_argument_type value; + return binder1st(op, value(x)); + } + + + /// bind2nd + /// + template + class binder2nd : public unary_function + { + protected: + Operation op; + typename Operation::second_argument_type value; + + public: + binder2nd(const Operation& x, const typename Operation::second_argument_type& y) + : op(x), value(y) { } + + typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const + { return op(x, value); } + + typename Operation::result_type operator()(typename Operation::first_argument_type& x) const + { return op(x, value); } + }; + + + template + inline binder2nd bind2nd(const Operation& op, const T& x) + { + typedef typename Operation::second_argument_type value; + return binder2nd(op, value(x)); + } + + + + + /////////////////////////////////////////////////////////////////////// + // pointer_to_unary_function + /////////////////////////////////////////////////////////////////////// + + /// pointer_to_unary_function + /// + /// This is an adapter template which converts a pointer to a standalone + /// function to a function object. This allows standalone functions to + /// work in many cases where the system requires a function object. + /// + /// Example usage: + /// ptrdiff_t Rand(ptrdiff_t n) { return rand() % n; } // Note: The C rand function is poor and slow. + /// pointer_to_unary_function randInstance(Rand); + /// random_shuffle(pArrayBegin, pArrayEnd, randInstance); + /// + template + class pointer_to_unary_function : public unary_function + { + protected: + Result (*mpFunction)(Arg); + + public: + pointer_to_unary_function() + { } + + explicit pointer_to_unary_function(Result (*pFunction)(Arg)) + : mpFunction(pFunction) { } + + Result operator()(Arg x) const + { return mpFunction(x); } + }; + + + /// ptr_fun + /// + /// This ptr_fun is simply shorthand for usage of pointer_to_unary_function. + /// + /// Example usage (actually, you don't need to use ptr_fun here, but it works anyway): + /// int factorial(int x) { return (x > 1) ? (x * factorial(x - 1)) : x; } + /// transform(pIntArrayBegin, pIntArrayEnd, pIntArrayBegin, ptr_fun(factorial)); + /// + template + inline pointer_to_unary_function ptr_fun(Result (*pFunction)(Arg)) + { return pointer_to_unary_function(pFunction); } + + + + + + /////////////////////////////////////////////////////////////////////// + // pointer_to_binary_function + /////////////////////////////////////////////////////////////////////// + + /// pointer_to_binary_function + /// + /// This is an adapter template which converts a pointer to a standalone + /// function to a function object. This allows standalone functions to + /// work in many cases where the system requires a function object. + /// + template + class pointer_to_binary_function : public binary_function + { + protected: + Result (*mpFunction)(Arg1, Arg2); + + public: + pointer_to_binary_function() + { } + + explicit pointer_to_binary_function(Result (*pFunction)(Arg1, Arg2)) + : mpFunction(pFunction) {} + + Result operator()(Arg1 x, Arg2 y) const + { return mpFunction(x, y); } + }; + + + /// This ptr_fun is simply shorthand for usage of pointer_to_binary_function. + /// + /// Example usage (actually, you don't need to use ptr_fun here, but it works anyway): + /// int multiply(int x, int y) { return x * y; } + /// transform(pIntArray1Begin, pIntArray1End, pIntArray2Begin, pIntArray1Begin, ptr_fun(multiply)); + /// + template + inline pointer_to_binary_function ptr_fun(Result (*pFunction)(Arg1, Arg2)) + { return pointer_to_binary_function(pFunction); } + + + + + + + /////////////////////////////////////////////////////////////////////// + // mem_fun + // mem_fun1 + // + // Note that mem_fun calls member functions via *pointers* to classes + // and not instances of classes. mem_fun_ref is for calling functions + // via instances of classes or references to classes. + // + /////////////////////////////////////////////////////////////////////// + + /// mem_fun_t + /// + /// Member function with no arguments. + /// + template + class mem_fun_t : public unary_function + { + public: + typedef Result (T::*MemberFunction)(); + + EA_FORCE_INLINE explicit mem_fun_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(T* pT) const + { + return (pT->*mpMemberFunction)(); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// mem_fun1_t + /// + /// Member function with one argument. + /// + template + class mem_fun1_t : public binary_function + { + public: + typedef Result (T::*MemberFunction)(Argument); + + EA_FORCE_INLINE explicit mem_fun1_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(T* pT, Argument arg) const + { + return (pT->*mpMemberFunction)(arg); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// const_mem_fun_t + /// + /// Const member function with no arguments. + /// Note that we inherit from unary_function + /// instead of what the C++ standard specifies: unary_function. + /// The C++ standard is in error and this has been recognized by the defect group. + /// + template + class const_mem_fun_t : public unary_function + { + public: + typedef Result (T::*MemberFunction)() const; + + EA_FORCE_INLINE explicit const_mem_fun_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(const T* pT) const + { + return (pT->*mpMemberFunction)(); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// const_mem_fun1_t + /// + /// Const member function with one argument. + /// Note that we inherit from unary_function + /// instead of what the C++ standard specifies: unary_function. + /// The C++ standard is in error and this has been recognized by the defect group. + /// + template + class const_mem_fun1_t : public binary_function + { + public: + typedef Result (T::*MemberFunction)(Argument) const; + + EA_FORCE_INLINE explicit const_mem_fun1_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(const T* pT, Argument arg) const + { + return (pT->*mpMemberFunction)(arg); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// mem_fun + /// + /// This is the high level interface to the mem_fun_t family. + /// + /// Example usage: + /// struct TestClass { void print() { puts("hello"); } } + /// TestClass* pTestClassArray[3] = { ... }; + /// for_each(pTestClassArray, pTestClassArray + 3, &TestClass::print); + /// + template + EA_FORCE_INLINE mem_fun_t + mem_fun(Result (T::*MemberFunction)()) + { + return eastl::mem_fun_t(MemberFunction); + } + + template + EA_FORCE_INLINE mem_fun1_t + mem_fun(Result (T::*MemberFunction)(Argument)) + { + return eastl::mem_fun1_t(MemberFunction); + } + + template + EA_FORCE_INLINE const_mem_fun_t + mem_fun(Result (T::*MemberFunction)() const) + { + return eastl::const_mem_fun_t(MemberFunction); + } + + template + EA_FORCE_INLINE const_mem_fun1_t + mem_fun(Result (T::*MemberFunction)(Argument) const) + { + return eastl::const_mem_fun1_t(MemberFunction); + } + + + + + + /////////////////////////////////////////////////////////////////////// + // mem_fun_ref + // mem_fun1_ref + // + /////////////////////////////////////////////////////////////////////// + + /// mem_fun_ref_t + /// + template + class mem_fun_ref_t : public unary_function + { + public: + typedef Result (T::*MemberFunction)(); + + EA_FORCE_INLINE explicit mem_fun_ref_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(T& t) const + { + return (t.*mpMemberFunction)(); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// mem_fun1_ref_t + /// + template + class mem_fun1_ref_t : public binary_function + { + public: + typedef Result (T::*MemberFunction)(Argument); + + EA_FORCE_INLINE explicit mem_fun1_ref_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(T& t, Argument arg) const + { + return (t.*mpMemberFunction)(arg); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// const_mem_fun_ref_t + /// + template + class const_mem_fun_ref_t : public unary_function + { + public: + typedef Result (T::*MemberFunction)() const; + + EA_FORCE_INLINE explicit const_mem_fun_ref_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(const T& t) const + { + return (t.*mpMemberFunction)(); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// const_mem_fun1_ref_t + /// + template + class const_mem_fun1_ref_t : public binary_function + { + public: + typedef Result (T::*MemberFunction)(Argument) const; + + EA_FORCE_INLINE explicit const_mem_fun1_ref_t(MemberFunction pMemberFunction) + : mpMemberFunction(pMemberFunction) + { + // Empty + } + + EA_FORCE_INLINE Result operator()(const T& t, Argument arg) const + { + return (t.*mpMemberFunction)(arg); + } + + protected: + MemberFunction mpMemberFunction; + }; + + + /// mem_fun_ref + /// Example usage: + /// struct TestClass { void print() { puts("hello"); } } + /// TestClass testClassArray[3]; + /// for_each(testClassArray, testClassArray + 3, &TestClass::print); + /// + template + EA_FORCE_INLINE mem_fun_ref_t + mem_fun_ref(Result (T::*MemberFunction)()) + { + return eastl::mem_fun_ref_t(MemberFunction); + } + + template + EA_FORCE_INLINE mem_fun1_ref_t + mem_fun_ref(Result (T::*MemberFunction)(Argument)) + { + return eastl::mem_fun1_ref_t(MemberFunction); + } + + template + EA_FORCE_INLINE const_mem_fun_ref_t + mem_fun_ref(Result (T::*MemberFunction)() const) + { + return eastl::const_mem_fun_ref_t(MemberFunction); + } + + template + EA_FORCE_INLINE const_mem_fun1_ref_t + mem_fun_ref(Result (T::*MemberFunction)(Argument) const) + { + return eastl::const_mem_fun1_ref_t(MemberFunction); + } + + + + + /////////////////////////////////////////////////////////////////////// + // hash + /////////////////////////////////////////////////////////////////////// + + template struct hash; + + template struct hash // Note that we use the pointer as-is and don't divide by sizeof(T*). This is because the table is of a prime size and this division doesn't benefit distribution. + { size_t operator()(T* p) const { return size_t(uintptr_t(p)); } }; + + template <> struct hash + { size_t operator()(bool val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(char val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(signed char val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(unsigned char val) const { return static_cast(val); } }; + + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + template <> struct hash + { size_t operator()(wchar_t val) const { return static_cast(val); } }; + #endif + + template <> struct hash + { size_t operator()(short val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(unsigned short val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(signed int val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(unsigned int val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(signed long val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(unsigned long val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(signed long long val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(unsigned long long val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(float val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(double val) const { return static_cast(val); } }; + + template <> struct hash + { size_t operator()(long double val) const { return static_cast(val); } }; + + + /////////////////////////////////////////////////////////////////////////// + // string hashes + // + // Note that our string hashes here intentionally are slow for long strings. + // The reasoning for this is so: + // - The large majority of hashed strings are only a few bytes long. + // - The hash function is significantly more efficient if it can make this assumption. + // - The user is welcome to make a custom hash for those uncommon cases where + // long strings need to be hashed. Indeed, the user can probably make a + // special hash customized for such strings that's better than what we provide. + /////////////////////////////////////////////////////////////////////////// + + template <> struct hash + { + size_t operator()(const char8_t* p) const + { + size_t c, result = 2166136261U; // FNV1 hash. Perhaps the best string hash. + while((c = (uint8_t)*p++) != 0) // Using '!=' disables compiler warnings. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + template <> struct hash + { + size_t operator()(const char8_t* p) const + { + size_t c, result = 2166136261U; + while((c = (uint8_t)*p++) != 0) // cast to unsigned 8 bit. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + template <> struct hash + { + size_t operator()(const char16_t* p) const + { + size_t c, result = 2166136261U; + while((c = (uint16_t)*p++) != 0) // cast to unsigned 16 bit. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + template <> struct hash + { + size_t operator()(const char16_t* p) const + { + size_t c, result = 2166136261U; + while((c = (uint16_t)*p++) != 0) // cast to unsigned 16 bit. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + template <> struct hash + { + size_t operator()(const char32_t* p) const + { + size_t c, result = 2166136261U; + while((c = (uint32_t)*p++) != 0) // cast to unsigned 32 bit. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + template <> struct hash + { + size_t operator()(const char32_t* p) const + { + size_t c, result = 2166136261U; + while((c = (uint32_t)*p++) != 0) // cast to unsigned 32 bit. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + /// string_hash + /// + /// Defines a generic string hash for an arbitrary EASTL basic_string container. + /// + /// Example usage: + /// eastl::hash_set > hashSet; + /// + template + struct string_hash + { + typedef String string_type; + typedef typename String::value_type value_type; + typedef typename eastl::add_unsigned::type unsigned_value_type; + + size_t operator()(const string_type& s) const + { + const unsigned_value_type* p = (const unsigned_value_type*)s.c_str(); + size_t c, result = 2166136261U; + while((c = *p++) != 0) + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + diff --git a/lib/eastl/include/EASTL/hash_map.h b/lib/eastl/include/EASTL/hash_map.h new file mode 100644 index 0000000..a46e1f2 --- /dev/null +++ b/lib/eastl/include/EASTL/hash_map.h @@ -0,0 +1,335 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/hash_map.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file is based on the TR1 (technical report 1) reference implementation +// of the unordered_set/unordered_map C++ classes as of about 4/2005. Most likely +// many or all C++ library vendors' implementations of this classes will be +// based off of the reference version and so will look pretty similar to this +// file as well as other vendors' versions. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_HASH_MAP_H +#define EASTL_HASH_MAP_H + + +#include +#include +#include +#include + + + +namespace eastl +{ + + /// EASTL_HASH_MAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_HASH_MAP_DEFAULT_NAME + #define EASTL_HASH_MAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hash_map" // Unless the user overrides something, this is "EASTL hash_map". + #endif + + + /// EASTL_HASH_MULTIMAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_HASH_MULTIMAP_DEFAULT_NAME + #define EASTL_HASH_MULTIMAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hash_multimap" // Unless the user overrides something, this is "EASTL hash_multimap". + #endif + + + /// EASTL_HASH_MAP_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_HASH_MAP_DEFAULT_ALLOCATOR + #define EASTL_HASH_MAP_DEFAULT_ALLOCATOR allocator_type(EASTL_HASH_MAP_DEFAULT_NAME) + #endif + + /// EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR + #define EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR allocator_type(EASTL_HASH_MULTIMAP_DEFAULT_NAME) + #endif + + + + /// hash_map + /// + /// Implements a hash_map, which is a hashed associative container. + /// Lookups are O(1) (that is, they are fast) but the container is + /// not sorted. + /// + /// set_max_load_factor + /// If you want to make a hashtable never increase its bucket usage, + /// call set_max_load_factor with a very high value such as 100000.f. + /// + /// bCacheHashCode + /// We provide the boolean bCacheHashCode template parameter in order + /// to allow the storing of the hash code of the key within the map. + /// When this option is disabled, the rehashing of the table will + /// call the hash function on the key. Setting bCacheHashCode to true + /// is useful for cases whereby the calculation of the hash value for + /// a contained object is very expensive. + /// + /// find_as + /// In order to support the ability to have a hashtable of strings but + /// be able to do efficiently lookups via char pointers (i.e. so they + /// aren't converted to string objects), we provide the find_as + /// function. This function allows you to do a find with a key of a + /// type other than the hashtable key type. + /// + /// Example find_as usage: + /// hash_map hashMap; + /// i = hashMap.find_as("hello"); // Use default hash and compare. + /// + /// Example find_as usage (namespaces omitted for brevity): + /// hash_map hashMap; + /// i = hashMap.find_as("hello", hash(), equal_to_2()); + /// + template , typename Predicate = eastl::equal_to, + typename Allocator = EASTLAllocatorType, bool bCacheHashCode = false> + class hash_map + : public hashtable, Allocator, eastl::use_first >, Predicate, + Hash, mod_range_hashing, default_ranged_hash, prime_rehash_policy, bCacheHashCode, true, true> + { + public: + typedef hashtable, Allocator, + eastl::use_first >, + Predicate, Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, true, true> base_type; + typedef hash_map this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::key_type key_type; + typedef T mapped_type; + typedef typename base_type::value_type value_type; // Note that this is pair. + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::insert_return_type insert_return_type; + typedef typename base_type::iterator iterator; + + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x has a bug which we work around. + using base_type::insert; + #endif + + public: + /// hash_map + /// + /// Default constructor. + /// + explicit hash_map(const allocator_type& allocator = EASTL_HASH_MAP_DEFAULT_ALLOCATOR) + : base_type(0, Hash(), mod_range_hashing(), default_ranged_hash(), + Predicate(), eastl::use_first >(), allocator) + { + // Empty + } + + + /// hash_map + /// + /// Constructor which creates an empty container, but start with nBucketCount buckets. + /// We default to a small nBucketCount value, though the user really should manually + /// specify an appropriate value in order to prevent memory from being reallocated. + /// + explicit hash_map(size_type nBucketCount, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MAP_DEFAULT_ALLOCATOR) + : base_type(nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), + predicate, eastl::use_first >(), allocator) + { + // Empty + } + + + /// hash_map + /// + /// An input bucket count of <= 1 causes the bucket count to be equal to the number of + /// elements in the input range. + /// + template + hash_map(ForwardIterator first, ForwardIterator last, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MAP_DEFAULT_ALLOCATOR) + : base_type(first, last, nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), + predicate, eastl::use_first >(), allocator) + { + // Empty + } + + + /// insert + /// + /// This is an extension to the C++ standard. We insert a default-constructed + /// element with the given key. The reason for this is that we can avoid the + /// potentially expensive operation of creating and/or copying a mapped_type + /// object on the stack. + insert_return_type insert(const key_type& key) + { + return base_type::DoInsertKey(key, true_type()); + } + + + #if defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around) + template + void insert(InputIterator first, InputIterator last) { return base_type::insert(first, last); } + insert_return_type insert(const value_type& value) { return base_type::insert(value); } + iterator insert(const_iterator it, const value_type& value) { return base_type::insert(it, value); } + #endif + + + mapped_type& operator[](const key_type& key) + { + const typename base_type::iterator it = base_type::find(key); + if(it != base_type::end()) + return (*it).second; + return (*base_type::insert(value_type(key, mapped_type())).first).second; + } + + }; // hash_map + + + + + + + /// hash_multimap + /// + /// Implements a hash_multimap, which is the same thing as a hash_map + /// except that contained elements need not be unique. See the + /// documentation for hash_set for details. + /// + template , typename Predicate = eastl::equal_to, + typename Allocator = EASTLAllocatorType, bool bCacheHashCode = false> + class hash_multimap + : public hashtable, Allocator, eastl::use_first >, Predicate, + Hash, mod_range_hashing, default_ranged_hash, prime_rehash_policy, bCacheHashCode, true, false> + { + public: + typedef hashtable, Allocator, + eastl::use_first >, + Predicate, Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, true, false> base_type; + typedef hash_multimap this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::key_type key_type; + typedef T mapped_type; + typedef typename base_type::value_type value_type; // Note that this is pair. + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::insert_return_type insert_return_type; + typedef typename base_type::iterator iterator; + + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x has a bug which we work around. + using base_type::insert; + #endif + + public: + /// hash_multimap + /// + /// Default constructor. + /// + explicit hash_multimap(const allocator_type& allocator = EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR) + : base_type(0, Hash(), mod_range_hashing(), default_ranged_hash(), + Predicate(), eastl::use_first >(), allocator) + { + // Empty + } + + + /// hash_multimap + /// + /// Constructor which creates an empty container, but start with nBucketCount buckets. + /// We default to a small nBucketCount value, though the user really should manually + /// specify an appropriate value in order to prevent memory from being reallocated. + /// + explicit hash_multimap(size_type nBucketCount, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR) + : base_type(nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), + predicate, eastl::use_first >(), allocator) + { + // Empty + } + + + /// hash_multimap + /// + /// An input bucket count of <= 1 causes the bucket count to be equal to the number of + /// elements in the input range. + /// + template + hash_multimap(ForwardIterator first, ForwardIterator last, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MULTIMAP_DEFAULT_ALLOCATOR) + : base_type(first, last, nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), + predicate, eastl::use_first >(), allocator) + { + // Empty + } + + + /// insert + /// + /// This is an extension to the C++ standard. We insert a default-constructed + /// element with the given key. The reason for this is that we can avoid the + /// potentially expensive operation of creating and/or copying a mapped_type + /// object on the stack. + insert_return_type insert(const key_type& key) + { + return base_type::DoInsertKey(key, false_type()); + } + + + #if defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around) + template + void insert(InputIterator first, InputIterator last) { return base_type::insert(first, last); } + insert_return_type insert(const value_type& value) { return base_type::insert(value); } + iterator insert(const_iterator it, const value_type& value) { return base_type::insert(it, value); } + #endif + + + }; // hash_multimap + + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + diff --git a/lib/eastl/include/EASTL/hash_set.h b/lib/eastl/include/EASTL/hash_set.h new file mode 100644 index 0000000..0256e07 --- /dev/null +++ b/lib/eastl/include/EASTL/hash_set.h @@ -0,0 +1,270 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/hash_set.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file is based on the TR1 (technical report 1) reference implementation +// of the unordered_set/unordered_map C++ classes as of about 4/2005. Most likely +// many or all C++ library vendors' implementations of this classes will be +// based off of the reference version and so will look pretty similar to this +// file as well as other vendors' versions. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_HASH_SET_H +#define EASTL_HASH_SET_H + + +#include +#include +#include +#include + + + +namespace eastl +{ + + /// EASTL_HASH_SET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_HASH_SET_DEFAULT_NAME + #define EASTL_HASH_SET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hash_set" // Unless the user overrides something, this is "EASTL hash_set". + #endif + + + /// EASTL_HASH_MULTISET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_HASH_MULTISET_DEFAULT_NAME + #define EASTL_HASH_MULTISET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hash_multiset" // Unless the user overrides something, this is "EASTL hash_multiset". + #endif + + + /// EASTL_HASH_SET_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_HASH_SET_DEFAULT_ALLOCATOR + #define EASTL_HASH_SET_DEFAULT_ALLOCATOR allocator_type(EASTL_HASH_SET_DEFAULT_NAME) + #endif + + /// EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR + #define EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR allocator_type(EASTL_HASH_MULTISET_DEFAULT_NAME) + #endif + + + + /// hash_set + /// + /// Implements a hash_set, which is a hashed unique-item container. + /// Lookups are O(1) (that is, they are fast) but the container is + /// not sorted. + /// + /// set_max_load_factor + /// If you want to make a hashtable never increase its bucket usage, + /// call set_max_load_factor with a very high value such as 100000.f. + /// + /// bCacheHashCode + /// We provide the boolean bCacheHashCode template parameter in order + /// to allow the storing of the hash code of the key within the map. + /// When this option is disabled, the rehashing of the table will + /// call the hash function on the key. Setting bCacheHashCode to true + /// is useful for cases whereby the calculation of the hash value for + /// a contained object is very expensive. + /// + /// find_as + /// In order to support the ability to have a hashtable of strings but + /// be able to do efficiently lookups via char pointers (i.e. so they + /// aren't converted to string objects), we provide the find_as + /// function. This function allows you to do a find with a key of a + /// type other than the hashtable key type. + /// + /// Example find_as usage: + /// hash_set hashSet; + /// i = hashSet.find_as("hello"); // Use default hash and compare. + /// + /// Example find_as usage (namespaces omitted for brevity): + /// hash_set hashSet; + /// i = hashSet.find_as("hello", hash(), equal_to_2()); + /// + template , typename Predicate = eastl::equal_to, + typename Allocator = EASTLAllocatorType, bool bCacheHashCode = false> + class hash_set + : public hashtable, Predicate, + Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, false, true> + { + public: + typedef hashtable, Predicate, + Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, false, true> base_type; + typedef hash_set this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::node_type node_type; + + public: + /// hash_set + /// + /// Default constructor. + /// + explicit hash_set(const allocator_type& allocator = EASTL_HASH_SET_DEFAULT_ALLOCATOR) + : base_type(0, Hash(), mod_range_hashing(), default_ranged_hash(), Predicate(), eastl::use_self(), allocator) + { + // Empty + } + + + /// hash_set + /// + /// Constructor which creates an empty container, but start with nBucketCount buckets. + /// We default to a small nBucketCount value, though the user really should manually + /// specify an appropriate value in order to prevent memory from being reallocated. + /// + explicit hash_set(size_type nBucketCount, const Hash& hashFunction = Hash(), const Predicate& predicate = Predicate(), + const allocator_type& allocator = EASTL_HASH_SET_DEFAULT_ALLOCATOR) + : base_type(nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), predicate, eastl::use_self(), allocator) + { + // Empty + } + + + /// hash_set + /// + /// An input bucket count of <= 1 causes the bucket count to be equal to the number of + /// elements in the input range. + /// + template + hash_set(FowardIterator first, FowardIterator last, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_SET_DEFAULT_ALLOCATOR) + : base_type(first, last, nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), predicate, eastl::use_self(), allocator) + { + // Empty + } + + }; // hash_set + + + + + + + /// hash_multiset + /// + /// Implements a hash_multiset, which is the same thing as a hash_set + /// except that contained elements need not be unique. See the documentation + /// for hash_set for details. + /// + template , typename Predicate = eastl::equal_to, + typename Allocator = EASTLAllocatorType, bool bCacheHashCode = false> + class hash_multiset + : public hashtable, Predicate, + Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, false, false> + { + public: + typedef hashtable, Predicate, + Hash, mod_range_hashing, default_ranged_hash, + prime_rehash_policy, bCacheHashCode, false, false> base_type; + typedef hash_multiset this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::node_type node_type; + + public: + /// hash_multiset + /// + /// Default constructor. + /// + explicit hash_multiset(const allocator_type& allocator = EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR) + : base_type(0, Hash(), mod_range_hashing(), default_ranged_hash(), Predicate(), eastl::use_self(), allocator) + { + // Empty + } + + + /// hash_multiset + /// + /// Constructor which creates an empty container, but start with nBucketCount buckets. + /// We default to a small nBucketCount value, though the user really should manually + /// specify an appropriate value in order to prevent memory from being reallocated. + /// + explicit hash_multiset(size_type nBucketCount, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR) + : base_type(nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), predicate, eastl::use_self(), allocator) + { + // Empty + } + + + /// hash_multiset + /// + /// An input bucket count of <= 1 causes the bucket count to be equal to the number of + /// elements in the input range. + /// + template + hash_multiset(FowardIterator first, FowardIterator last, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), + const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MULTISET_DEFAULT_ALLOCATOR) + : base_type(first, last, nBucketCount, hashFunction, mod_range_hashing(), default_ranged_hash(), predicate, eastl::use_self(), allocator) + { + // Empty + } + + + }; // hash_multiset + + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/heap.h b/lib/eastl/include/EASTL/heap.h new file mode 100644 index 0000000..c7566f3 --- /dev/null +++ b/lib/eastl/include/EASTL/heap.h @@ -0,0 +1,592 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/heap.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements heap functionality much like the std C++ heap algorithms. +// Such heaps are not the same thing as memory heaps or pools, but rather are +// semi-sorted random access containers which have the primary purpose of +// supporting the implementation of priority_queue and similar data structures. +// +// The primary distinctions between this heap functionality and std::heap are: +// - This heap exposes some extra functionality such as is_heap and change_heap. +// - This heap is more efficient than versions found in typical STL +// implementations. This comes +// about due to better use of array dereferencing and branch prediction. +// You should expect of 5-30%, depending on the usage and platform. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// The publicly usable functions we define are: +// push_heap -- Adds an entry to a heap. Same as C++ std::push_heap. +// pop_heap -- Removes the top entry from a heap. Same as C++ std::pop_heap. +// make_heap -- Converts an array to a heap. Same as C++ std::make_heap. +// sort_heap -- Sorts a heap in place. Same as C++ std::sort_heap. +// remove_heap -- Removes an arbitrary entry from a heap. +// change_heap -- Changes the priority of an entry in the heap. +// is_heap -- Returns true if an array appears is in heap format. +/////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_HEAP_H +#define EASTL_HEAP_H + + +#include +#include +#include + + + +namespace eastl +{ + + /////////////////////////////////////////////////////////////////////// + // promote_heap (internal function) + /////////////////////////////////////////////////////////////////////// + + /// promote_heap + /// + /// Moves a value in the heap from a given position upward until + /// it is sorted correctly. It's kind of like bubble-sort, except that + /// instead of moving linearly from the back of a list to the front, + /// it moves from the bottom of the tree up the branches towards the + /// top. But otherwise is just like bubble-sort. + /// + /// This function requires that the value argument refer to a value + /// that is currently not within the heap. + /// + template + inline void promote_heap(RandomAccessIterator first, Distance topPosition, Distance position, const T& value) + { + for(Distance parentPosition = (position - 1) >> 1; // This formula assumes that (position > 0). // We use '>> 1' instead of '/ 2' because we have seen VC++ generate better code with >>. + (position > topPosition) && (*(first + parentPosition) < value); + parentPosition = (position - 1) >> 1) + { + *(first + position) = *(first + parentPosition); // Swap the node with its parent. + position = parentPosition; + } + + *(first + position) = value; + } + + /// promote_heap + /// + /// Takes a Compare(a, b) function (or function object) which returns true if a < b. + /// For example, you could use the standard 'less' comparison object. + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + /// This function requires that the value argument refer to a value + /// that is currently not within the heap. + /// + template + inline void promote_heap(RandomAccessIterator first, Distance topPosition, Distance position, const T& value, Compare compare) + { + for(Distance parentPosition = (position - 1) >> 1; // This formula assumes that (position > 0). // We use '>> 1' instead of '/ 2' because we have seen VC++ generate better code with >>. + (position > topPosition) && compare(*(first + parentPosition), value); + parentPosition = (position - 1) >> 1) + { + *(first + position) = *(first + parentPosition); // Swap the node with its parent. + position = parentPosition; + } + + *(first + position) = value; + } + + + + /////////////////////////////////////////////////////////////////////// + // adjust_heap (internal function) + /////////////////////////////////////////////////////////////////////// + + /// adjust_heap + /// + /// Given a position that has just been vacated, this function moves + /// new values into that vacated position appropriately. The value + /// argument is an entry which will be inserted into the heap after + /// we move nodes into the positions that were vacated. + /// + /// This function requires that the value argument refer to a value + /// that is currently not within the heap. + /// + template + void adjust_heap(RandomAccessIterator first, Distance topPosition, Distance heapSize, Distance position, const T& value) + { + // We do the conventional approach of moving the position down to the + // bottom then inserting the value at the back and moving it up. + Distance childPosition = (2 * position) + 2; + + for(; childPosition < heapSize; childPosition = (2 * childPosition) + 2) + { + if(*(first + childPosition) < *(first + (childPosition - 1))) // Choose the larger of the two children. + --childPosition; + *(first + position) = *(first + childPosition); // Swap positions with this child. + position = childPosition; + } + + if(childPosition == heapSize) // If we are at the very last index of the bottom... + { + *(first + position) = *(first + (childPosition - 1)); + position = childPosition - 1; + } + + eastl::promote_heap(first, topPosition, position, value); + } + + + /// adjust_heap + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + /// This function requires that the value argument refer to a value + /// that is currently not within the heap. + /// + template + void adjust_heap(RandomAccessIterator first, Distance topPosition, Distance heapSize, Distance position, const T& value, Compare compare) + { + // We do the conventional approach of moving the position down to the + // bottom then inserting the value at the back and moving it up. + Distance childPosition = (2 * position) + 2; + + for(; childPosition < heapSize; childPosition = (2 * childPosition) + 2) + { + if(compare(*(first + childPosition), *(first + (childPosition - 1)))) // Choose the larger of the two children. + --childPosition; + *(first + position) = *(first + childPosition); // Swap positions with this child. + position = childPosition; + } + + if(childPosition == heapSize) // If we are at the bottom... + { + *(first + position) = *(first + (childPosition - 1)); + position = childPosition - 1; + } + + eastl::promote_heap(first, topPosition, position, value, compare); + } + + + + + /////////////////////////////////////////////////////////////////////// + // push_heap + /////////////////////////////////////////////////////////////////////// + + /// push_heap + /// + /// Adds an item to a heap (which is an array). The item necessarily + /// comes from the back of the heap (array). Thus, the insertion of a + /// new item in a heap is a two step process: push_back and push_heap. + /// + /// Example usage: + /// vector heap; + /// + /// heap.push_back(3); + /// push_heap(heap.begin(), heap.end()); // Places '3' appropriately. + /// + template + inline void push_heap(RandomAccessIterator first, RandomAccessIterator last) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(last - 1)); + + eastl::promote_heap + (first, (difference_type)0, (difference_type)(last - first - 1), tempBottom); + } + + + /// push_heap + /// + /// This version is useful for cases where your object comparison is unusual + /// or where you want to have the heap store pointers to objects instead of + /// storing the objects themselves (often in order to improve cache coherency + /// while doing sorting). + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + template + inline void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(last - 1)); + + eastl::promote_heap + (first, (difference_type)0, (difference_type)(last - first - 1), tempBottom, compare); + } + + + + + /////////////////////////////////////////////////////////////////////// + // pop_heap + /////////////////////////////////////////////////////////////////////// + + /// pop_heap + /// + /// Removes the first item from the heap (which is an array), and adjusts + /// the heap so that the highest priority item becomes the new first item. + /// + /// Example usage: + /// vector heap; + /// + /// heap.push_back(2); + /// heap.push_back(3); + /// heap.push_back(1); + /// + /// pop_heap(heap.begin(), heap.end()); // Moves heap[0] to the back of the heap and adjusts the heap. + /// heap.pop_back(); // Remove value that was just at the top of the heap + /// + template + inline void pop_heap(RandomAccessIterator first, RandomAccessIterator last) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(last - 1)); + *(last - 1) = *first; + eastl::adjust_heap + (first, (difference_type)0, (difference_type)(last - first - 1), 0, tempBottom); + } + + + + /// pop_heap + /// + /// This version is useful for cases where your object comparison is unusual + /// or where you want to have the heap store pointers to objects instead of + /// storing the objects themselves (often in order to improve cache coherency + /// while doing sorting). + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + template + inline void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(last - 1)); + *(last - 1) = *first; + eastl::adjust_heap + (first, (difference_type)0, (difference_type)(last - first - 1), 0, tempBottom, compare); + } + + + + + /////////////////////////////////////////////////////////////////////// + // make_heap + /////////////////////////////////////////////////////////////////////// + + + /// make_heap + /// + /// Given an array, this function converts it into heap format. + /// The complexity is O(n), where n is count of the range. + /// The input range is not required to be in any order. + /// + template + void make_heap(RandomAccessIterator first, RandomAccessIterator last) + { + // We do bottom-up heap construction as per Sedgewick. Such construction is O(n). + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const difference_type heapSize = last - first; + + if(heapSize >= 2) // If there is anything to do... (we need this check because otherwise the math fails below). + { + difference_type parentPosition = ((heapSize - 2) >> 1) + 1; // We use '>> 1' instead of '/ 2' because we have seen VC++ generate better code with >>. + + do{ + --parentPosition; + const value_type temp(*(first + parentPosition)); + eastl::adjust_heap + (first, parentPosition, heapSize, parentPosition, temp); + } while(parentPosition != 0); + } + } + + + template + void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const difference_type heapSize = last - first; + + if(heapSize >= 2) // If there is anything to do... (we need this check because otherwise the math fails below). + { + difference_type parentPosition = ((heapSize - 2) >> 1) + 1; // We use '>> 1' instead of '/ 2' because we have seen VC++ generate better code with >>. + + do{ + --parentPosition; + const value_type temp(*(first + parentPosition)); + eastl::adjust_heap + (first, parentPosition, heapSize, parentPosition, temp, compare); + } while(parentPosition != 0); + } + } + + + + + /////////////////////////////////////////////////////////////////////// + // sort_heap + /////////////////////////////////////////////////////////////////////// + + /// sort_heap + /// + /// After the application if this algorithm, the range it was applied to + /// is no longer a heap, though it will be a reverse heap (smallest first). + /// The item with the lowest priority will be first, and the highest last. + /// This is not a stable sort because the relative order of equivalent + /// elements is not necessarily preserved. + /// The range referenced must be valid; all pointers must be dereferenceable + /// and within the sequence the last position is reachable from the first + /// by incrementation. + /// The complexity is at most O(n * log(n)), where n is count of the range. + /// + template + inline void sort_heap(RandomAccessIterator first, RandomAccessIterator last) + { + for(; (last - first) > 1; --last) // We simply use the heap to sort itself. + eastl::pop_heap(first, last); + } + + + /// sort_heap + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + template + inline void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + for(; (last - first) > 1; --last) // We simply use the heap to sort itself. + eastl::pop_heap(first, last, compare); + } + + + + /////////////////////////////////////////////////////////////////////// + // remove_heap + /////////////////////////////////////////////////////////////////////// + + /// remove_heap + /// + /// Removes an arbitrary entry from the heap and adjusts the heap appropriately. + /// This function is unlike pop_heap in that pop_heap moves the top item + /// to the back of the heap, whereas remove_heap moves an arbitrary item to + /// the back of the heap. + /// + /// Note: Since this function moves the element to the back of the heap and + /// doesn't actually remove it from the given container, the user must call + /// the container erase function if the user wants to erase the element + /// from the container. + /// + template + inline void remove_heap(RandomAccessIterator first, Distance heapSize, Distance position) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(first + heapSize - 1)); + *(first + heapSize - 1) = *(first + position); + eastl::adjust_heap + (first, (difference_type)0, (difference_type)(heapSize - 1), (difference_type)position, tempBottom); + } + + + /// remove_heap + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + /// Note: Since this function moves the element to the back of the heap and + /// doesn't actually remove it from the given container, the user must call + /// the container erase function if the user wants to erase the element + /// from the container. + /// + template + inline void remove_heap(RandomAccessIterator first, Distance heapSize, Distance position, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const value_type tempBottom(*(first + heapSize - 1)); + *(first + heapSize - 1) = *(first + position); + eastl::adjust_heap + (first, (difference_type)0, (difference_type)(heapSize - 1), (difference_type)position, tempBottom, compare); + } + + + + /////////////////////////////////////////////////////////////////////// + // change_heap + /////////////////////////////////////////////////////////////////////// + + /// change_heap + /// + /// Given a value in the heap that has changed in priority, this function + /// adjusts the heap appropriately. The heap size remains unchanged after + /// this operation. + /// + template + inline void change_heap(RandomAccessIterator first, Distance heapSize, Distance position) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + eastl::remove_heap(first, heapSize, position); + + value_type tempBottom(*(first + heapSize - 1)); + + eastl::promote_heap + (first, (difference_type)0, (difference_type)(heapSize - 1), tempBottom); + } + + + /// change_heap + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + template + inline void change_heap(RandomAccessIterator first, Distance heapSize, Distance position, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + eastl::remove_heap(first, heapSize, position, compare); + + value_type tempBottom(*(first + heapSize - 1)); + + eastl::promote_heap + (first, (difference_type)0, (difference_type)(heapSize - 1), tempBottom, compare); + } + + + + + + /////////////////////////////////////////////////////////////////////// + // is_heap + /////////////////////////////////////////////////////////////////////// + + /// is_heap + /// + /// This is a useful debugging algorithm for verifying that a random + /// access container is in heap format. + /// + template + inline bool is_heap(RandomAccessIterator first, RandomAccessIterator last) + { + int counter = 0; + + for(RandomAccessIterator child = first + 1; child < last; ++child, counter ^= 1) + { + if(*first < *child) + return false; + first += counter; // counter switches between 0 and 1 every time through. + } + + return true; + } + + + /// is_heap + /// + /// The Compare function must work equivalently to the compare function used + /// to make and maintain the heap. + /// + template + inline bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + int counter = 0; + + for(RandomAccessIterator child = first + 1; child < last; ++child, counter ^= 1) + { + if(compare(*first, *child)) + return false; + first += counter; // counter switches between 0 and 1 every time through. + } + + return true; + } + + + + // Faster implementation for most cases: + // + // template + // inline bool is_heap(RandomAccessIterator first, RandomAccessIterator last) + // { + // if(((uintptr_t)(last - first) & 1) == 0) + // --last; + // + // RandomAccessIterator parent = first, child = first + 1; + // + // for(; child < last; child += 2, ++parent) + // { + // if((*parent < *child) || (*parent < *(child + 1))) + // return false; + // } + // + // if((((uintptr_t)(last - first) & 1) == 0) && (*parent < *child)) + // return false; + // + // return true; + // } + + +} // namespace eastl + + +#endif // Header include guard + + + + diff --git a/lib/eastl/include/EASTL/internal/config.h b/lib/eastl/include/EASTL/internal/config.h new file mode 100644 index 0000000..16ef960 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/config.h @@ -0,0 +1,1207 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/config.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_CONFIG_H +#define EASTL_INTERNAL_CONFIG_H + + +/////////////////////////////////////////////////////////////////////////////// +// ReadMe +// +// This is the EASTL configuration file. All configurable parameters of EASTL +// are controlled through this file. However, all the settings here can be +// manually overridden by the user. There are three ways for a user to override +// the settings in this file: +// +// - Simply edit this file. +// - Define EASTL_USER_CONFIG_HEADER. +// - Predefine individual defines (e.g. EASTL_ASSERT). +// +/////////////////////////////////////////////////////////////////////////////// + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_USER_CONFIG_HEADER +// +// This allows the user to define a header file to be #included before the +// EASTL config.h contents are compiled. A primary use of this is to override +// the contents of this config.h file. Note that all the settings below in +// this file are user-overridable. +// +// Example usage: +// #define EASTL_USER_CONFIG_HEADER "MyConfigOverrides.h" +// #include +// +/////////////////////////////////////////////////////////////////////////////// + +#ifdef EASTL_USER_CONFIG_HEADER + #include EASTL_USER_CONFIG_HEADER +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_EABASE_DISABLED +// +// The user can disable EABase usage and manually supply the configuration +// via defining EASTL_EABASE_DISABLED and defining the appropriate entities +// globally or via the above EASTL_USER_CONFIG_HEADER. +// +// Example usage: +// #define EASTL_EABASE_DISABLED +// #include +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_EABASE_DISABLED + #include +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// VC++ bug fix. +/////////////////////////////////////////////////////////////////////////////// + +#ifdef _MSC_VER + // VC8 has a bug whereby it generates a warning when malloc.h is #included + // by its headers instead of by yours. There is no practical solution but + // to pre-empt the #include of malloc.h with our own inclusion of it. + // The only other alternative is to disable the warning globally, which is + // something we try to avoid as much as possible. + #pragma warning(push, 0) + #include + #pragma warning(pop) +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_VERSION +// +// We more or less follow the conventional EA packaging approach to versioning +// here. A primary distinction here is that minor versions are defined as two +// digit entities (e.g. .03") instead of minimal digit entities ".3"). The logic +// here is that the value is a counter and not a floating point fraction. +// Note that the major version doesn't have leading zeros. +// +// Example version strings: +// "0.91.00" // Major version 0, minor version 91, patch version 0. +// "1.00.00" // Major version 1, minor and patch version 0. +// "3.10.02" // Major version 3, minor version 10, patch version 02. +// "12.03.01" // Major version 12, minor version 03, patch version +// +// Example usage: +// printf("EASTL version: %s", EASTL_VERSION); +// printf("EASTL version: %d.%d.%d", EASTL_VERSION_N / 10000 % 100, EASTL_VERSION_N / 100 % 100, EASTL_VERSION_N % 100); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_VERSION + #define EASTL_VERSION "1.11.03" + #define EASTL_VERSION_N 11103 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EA_PLATFORM_MICROSOFT +// +// Defined as 1 or undefined. +// Implements support for the definition of EA_PLATFORM_MICROSOFT for the case +// of using EABase versions prior to the addition of its EA_PLATFORM_MICROSOFT support. +// +#if (EABASE_VERSION_N < 20022) && !defined(EA_PLATFORM_MICROSOFT) + #if defined(EA_PLATFORM_WINDOWS) || defined(EA_PLATFORM_XENON) + #define EA_PLATFORM_MICROSOFT 1 + #endif +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// EA_COMPILER_NO_STANDARD_CPP_LIBRARY +// +// Defined as 1 or undefined. +// Implements support for the definition of EA_COMPILER_NO_STANDARD_CPP_LIBRARY for the case +// of using EABase versions prior to the addition of its EA_COMPILER_NO_STANDARD_CPP_LIBRARY support. +// +#if (EABASE_VERSION_N < 20022) && !defined(EA_COMPILER_NO_STANDARD_CPP_LIBRARY) + #if defined(EA_PLATFORM_ANDROID) + #define EA_COMPILER_NO_STANDARD_CPP_LIBRARY 1 + #endif +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// EA_COMPILER_NO_RTTI +// +// Defined as 1 or undefined. +// Implements support for the definition of EA_COMPILER_NO_RTTI for the case +// of using EABase versions prior to the addition of its EA_COMPILER_NO_RTTI support. +// +#if (EABASE_VERSION_N < 20022) && !defined(EA_COMPILER_NO_RTTI) + #if defined(__SNC__) && !defined(__RTTI) + #define EA_COMPILER_NO_RTTI + #elif defined(__GXX_ABI_VERSION) && !defined(__GXX_RTTI) + #define EA_COMPILER_NO_RTTI + #elif defined(_MSC_VER) && !defined(_CPPRTTI) + #define EA_COMPILER_NO_RTTI + #elif defined(__MWERKS__) + #if !__option(RTTI) + #define EA_COMPILER_NO_RTTI + #endif + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL namespace +// +// We define this so that users that #include this config file can reference +// these namespaces without seeing any other files that happen to use them. +/////////////////////////////////////////////////////////////////////////////// + +/// EA Standard Template Library +namespace eastl +{ + // Intentionally empty. +} + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_DEBUG +// +// Defined as an integer >= 0. Default is 1 for debug builds and 0 for +// release builds. This define is also a master switch for the default value +// of some other settings. +// +// Example usage: +// #if EASTL_DEBUG +// ... +// #endif +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_DEBUG + #if defined(EA_DEBUG) || defined(_DEBUG) + #define EASTL_DEBUG 1 + #else + #define EASTL_DEBUG 0 + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_DEBUGPARAMS_LEVEL +// +// EASTL_DEBUGPARAMS_LEVEL controls what debug information is passed through to +// the allocator by default. +// This value may be defined by the user ... if not it will default to 1 for +// EA_DEBUG builds, otherwise 0. +// +// 0 - no debug information is passed through to allocator calls. +// 1 - 'name' is passed through to allocator calls. +// 2 - 'name', __FILE__, and __LINE__ are passed through to allocator calls. +// +// This parameter mirrors the equivalent parameter in the CoreAllocator package. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_DEBUGPARAMS_LEVEL + #if EASTL_DEBUG + #define EASTL_DEBUGPARAMS_LEVEL 2 + #else + #define EASTL_DEBUGPARAMS_LEVEL 0 + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_DLL +// +// Defined as 0 or 1. The default is dependent on the definition of EA_DLL. +// If EA_DLL is defined, then EASTL_DLL is 1, else EASTL_DLL is 0. +// EA_DLL is a define that controls DLL builds within the EAConfig build system. +// EASTL_DLL controls whether EASTL is built and used as a DLL. +// Normally you wouldn't do such a thing, but there are use cases for such +// a thing, particularly in the case of embedding C++ into C# applications. +// +#ifndef EASTL_DLL + #if defined(EA_DLL) + #define EASTL_DLL 1 + #else + #define EASTL_DLL 0 + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_API +// +// This is used to label functions as DLL exports under Microsoft platforms. +// If EA_DLL is defined, then the user is building EASTL as a DLL and EASTL's +// non-templated functions will be exported. EASTL template functions are not +// labelled as EASTL_API (and are thus not exported in a DLL build). This is +// because it's not possible (or at least unsafe) to implement inline templated +// functions in a DLL. +// +// Example usage of EASTL_API: +// EASTL_API int someVariable = 10; // Export someVariable in a DLL build. +// +// struct EASTL_API SomeClass{ // Export SomeClass and its member functions in a DLL build. +// }; +// +// EASTL_API void SomeFunction(); // Export SomeFunction in a DLL build. +// +// +#if defined(EA_DLL) && !defined(EASTL_DLL) + #define EASTL_DLL 1 +#endif + +#ifndef EASTL_API // If the build file hasn't already defined this to be dllexport... + #if EASTL_DLL && defined(_MSC_VER) + #define EASTL_API __declspec(dllimport) + #define EASTL_TEMPLATE_API // Not sure if there is anything we can do here. + #else + #define EASTL_API + #define EASTL_TEMPLATE_API + #endif +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_NAME_ENABLED / EASTL_NAME / EASTL_NAME_VAL +// +// Used to wrap debug string names. In a release build, the definition +// goes away. These are present to avoid release build compiler warnings +// and to make code simpler. +// +// Example usage of EASTL_NAME: +// // pName will defined away in a release build and thus prevent compiler warnings. +// void allocator::set_name(const char* EASTL_NAME(pName)) +// { +// #if EASTL_NAME_ENABLED +// mpName = pName; +// #endif +// } +// +// Example usage of EASTL_NAME_VAL: +// // "xxx" is defined to NULL in a release build. +// vector::vector(const allocator_type& allocator = allocator_type(EASTL_NAME_VAL("xxx"))); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_NAME_ENABLED + #define EASTL_NAME_ENABLED EASTL_DEBUG +#endif + +#ifndef EASTL_NAME + #if EASTL_NAME_ENABLED + #define EASTL_NAME(x) x + #define EASTL_NAME_VAL(x) x + #else + #define EASTL_NAME(x) + #define EASTL_NAME_VAL(x) ((const char*)NULL) + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_DEFAULT_NAME_PREFIX +// +// Defined as a string literal. Defaults to "EASTL". +// This define is used as the default name for EASTL where such a thing is +// referenced in EASTL. For example, if the user doesn't specify an allocator +// name for their deque, it is named "EASTL deque". However, you can override +// this to say "SuperBaseball deque" by changing EASTL_DEFAULT_NAME_PREFIX. +// +// Example usage (which is simply taken from how deque.h uses this define): +// #ifndef EASTL_DEQUE_DEFAULT_NAME +// #define EASTL_DEQUE_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " deque" +// #endif +// +#ifndef EASTL_DEFAULT_NAME_PREFIX + #define EASTL_DEFAULT_NAME_PREFIX "EASTL" +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ASSERT_ENABLED +// +// Defined as 0 or non-zero. Default is same as EASTL_DEBUG. +// If EASTL_ASSERT_ENABLED is non-zero, then asserts will be executed via +// the assertion mechanism. +// +// Example usage: +// #if EASTL_ASSERT_ENABLED +// EASTL_ASSERT(v.size() > 17); +// #endif +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ASSERT_ENABLED + #define EASTL_ASSERT_ENABLED EASTL_DEBUG +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_EMPTY_REFERENCE_ASSERT_ENABLED +// +// Defined as 0 or non-zero. Default is same as EASTL_ASSERT_ENABLED. +// This is like EASTL_ASSERT_ENABLED, except it is for empty container +// references. Sometime people like to be able to take a reference to +// the front of the container, but not use it if the container is empty. +// In practice it's often easier and more efficient to do this than to write +// extra code to check if the container is empty. +// +// Example usage: +// template +// inline typename vector::reference +// vector::front() +// { +// #if EASTL_ASSERT_ENABLED +// EASTL_ASSERT(mpEnd > mpBegin); +// #endif +// +// return *mpBegin; +// } +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + #define EASTL_EMPTY_REFERENCE_ASSERT_ENABLED EASTL_ASSERT_ENABLED +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// SetAssertionFailureFunction +// +// Allows the user to set a custom assertion failure mechanism. +// +// Example usage: +// void Assert(const char* pExpression, void* pContext); +// SetAssertionFailureFunction(Assert, this); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ASSERTION_FAILURE_DEFINED + #define EASTL_ASSERTION_FAILURE_DEFINED + + namespace eastl + { + typedef void (*EASTL_AssertionFailureFunction)(const char* pExpression, void* pContext); + EASTL_API void SetAssertionFailureFunction(EASTL_AssertionFailureFunction pFunction, void* pContext); + + // These are the internal default functions that implement asserts. + EASTL_API void AssertionFailure(const char* pExpression); + EASTL_API void AssertionFailureFunctionDefault(const char* pExpression, void* pContext); + } +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ASSERT +// +// Assertion macro. Can be overridden by user with a different value. +// +// Example usage: +// EASTL_ASSERT(intVector.size() < 100); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ASSERT + #if EASTL_ASSERT_ENABLED + #define EASTL_ASSERT(expression) (void)((expression) || (eastl::AssertionFailure(#expression), 0)) + #else + #define EASTL_ASSERT(expression) + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_FAIL_MSG +// +// Failure macro. Can be overridden by user with a different value. +// +// Example usage: +// EASTL_FAIL("detected error condition!"); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_FAIL_MSG + #if EASTL_ASSERT_ENABLED + #define EASTL_FAIL_MSG(message) (eastl::AssertionFailure(message)) + #else + #define EASTL_FAIL_MSG(message) + #endif +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_CT_ASSERT / EASTL_CT_ASSERT_NAMED +// +// EASTL_CT_ASSERT is a macro for compile time assertion checks, useful for +// validating *constant* expressions. The advantage over using EASTL_ASSERT +// is that errors are caught at compile time instead of runtime. +// +// Example usage: +// EASTL_CT_ASSERT(sizeof(uint32_t == 4)); +// +/////////////////////////////////////////////////////////////////////////////// + +#if defined(EASTL_DEBUG) && !defined(EASTL_CT_ASSERT) + template struct EASTL_CT_ASSERTION_FAILURE; + template <> struct EASTL_CT_ASSERTION_FAILURE{ enum { value = 1 }; }; // We create a specialization for true, but not for false. + template struct EASTL_CT_ASSERTION_TEST{}; + + #define EASTL_PREPROCESSOR_JOIN(a, b) EASTL_PREPROCESSOR_JOIN1(a, b) + #define EASTL_PREPROCESSOR_JOIN1(a, b) EASTL_PREPROCESSOR_JOIN2(a, b) + #define EASTL_PREPROCESSOR_JOIN2(a, b) a##b + + #if defined(_MSC_VER) + #define EASTL_CT_ASSERT(expression) typedef EASTL_CT_ASSERTION_TEST< sizeof(EASTL_CT_ASSERTION_FAILURE< (bool)(expression) >)> EASTL_CT_ASSERT_FAILURE + #elif defined(__ICL) || defined(__ICC) + #define EASTL_CT_ASSERT(expression) typedef char EASTL_PREPROCESSOR_JOIN(EASTL_CT_ASSERT_FAILURE_, __LINE__) [EASTL_CT_ASSERTION_FAILURE< (bool)(expression) >::value] + #elif defined(__MWERKS__) + #define EASTL_CT_ASSERT(expression) enum { EASTL_PREPROCESSOR_JOIN(EASTL_CT_ASSERT_FAILURE_, __LINE__) = sizeof(EASTL_CT_ASSERTION_FAILURE< (bool)(expression) >) } + #else // GCC, etc. + #define EASTL_CT_ASSERT(expression) typedef EASTL_CT_ASSERTION_TEST< sizeof(EASTL_CT_ASSERTION_FAILURE< (bool)(expression) >)> EASTL_PREPROCESSOR_JOIN1(EASTL_CT_ASSERT_FAILURE_, __LINE__) + #endif +#else + #define EASTL_CT_ASSERT(expression) +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_DEBUG_BREAK +// +// This function causes an app to immediately stop under the debugger. +// It is implemented as a macro in order to allow stopping at the site +// of the call. +// +// +// Example usage: +// EASTL_DEBUG_BREAK(); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_DEBUG_BREAK + #if defined(_MSC_VER) && (_MSC_VER >= 1300) + #define EASTL_DEBUG_BREAK() __debugbreak() // This is a compiler intrinsic which will map to appropriate inlined asm for the platform. + #elif defined(EA_PROCESSOR_MIPS) // + #define EASTL_DEBUG_BREAK() asm("break") + #elif defined(__SNC__) + #define EASTL_DEBUG_BREAK() *(int*)(0) = 0 + #elif defined(EA_PLATFORM_PS3) + #define EASTL_DEBUG_BREAK() asm volatile("tw 31,1,1") + #elif defined(EA_PROCESSOR_POWERPC) // Generic PowerPC. + #define EASTL_DEBUG_BREAK() asm(".long 0") // This triggers an exception by executing opcode 0x00000000. + #elif (defined(EA_PROCESSOR_X86) || defined(EA_PROCESSOR_X86_64)) && defined(EA_ASM_STYLE_INTEL) + // NOTE by Gered: had to change this so Marmalade builds would compile under Xcode 4.3 + // not sure if this is correct (could be the EASTL platform detection is messed up) + #define EASTL_DEBUG_BREAK() __asm__ ("int $3") + #elif (defined(EA_PROCESSOR_X86) || defined(EA_PROCESSOR_X86_64)) && (defined(EA_ASM_STYLE_ATT) || defined(__GNUC__)) + #define EASTL_DEBUG_BREAK() asm("int3") + #else + void EASTL_DEBUG_BREAK(); // User must define this externally. + #endif +#else + void EASTL_DEBUG_BREAK(); // User must define this externally. +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ALLOCATOR_COPY_ENABLED +// +// Defined as 0 or 1. Default is 0 (disabled) until some future date. +// If enabled (1) then container operator= copies the allocator from the +// source container. It ideally should be set to enabled but for backwards +// compatibility with older versions of EASTL it is currently set to 0. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ALLOCATOR_COPY_ENABLED + #define EASTL_ALLOCATOR_COPY_ENABLED 0 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_FIXED_SIZE_TRACKING_ENABLED +// +// Defined as an integer >= 0. Default is same as EASTL_DEBUG. +// If EASTL_FIXED_SIZE_TRACKING_ENABLED is enabled, then fixed +// containers in debug builds track the max count of objects +// that have been in the container. This allows for the tuning +// of fixed container sizes to their minimum required size. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_FIXED_SIZE_TRACKING_ENABLED + #define EASTL_FIXED_SIZE_TRACKING_ENABLED EASTL_DEBUG +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_RTTI_ENABLED +// +// Defined as 0 or 1. Default is 1 if RTTI is supported by the compiler. +// This define exists so that we can use some dynamic_cast operations in the +// code without warning. dynamic_cast is only used if the specifically refers +// to it; EASTL won't do dynamic_cast behind your back. +// +// Example usage: +// #if EASTL_RTTI_ENABLED +// pChildClass = dynamic_cast(pParentClass); +// #endif +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_RTTI_ENABLED + #if defined(EA_COMPILER_NO_RTTI) + #define EASTL_RTTI_ENABLED 0 + #else + #define EASTL_RTTI_ENABLED 1 + #endif +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_EXCEPTIONS_ENABLED +// +// Defined as 0 or 1. Default is to follow what the compiler settings are. +// The user can predefine EASTL_EXCEPTIONS_ENABLED to 0 or 1; however, if the +// compiler is set to disable exceptions then EASTL_EXCEPTIONS_ENABLED is +// forced to a value of 0 regardless of the user predefine. +// +/////////////////////////////////////////////////////////////////////////////// + +#if !defined(EASTL_EXCEPTIONS_ENABLED) || ((EASTL_EXCEPTIONS_ENABLED == 1) && defined(EA_COMPILER_NO_EXCEPTIONS)) + #define EASTL_EXCEPTIONS_ENABLED 0 +#endif + + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_STRING_OPT_XXXX +// +// Enables some options / optimizations options that cause the string class +// to behave slightly different from the C++ standard basic_string. These are +// options whereby you can improve performance by avoiding operations that +// in practice may never occur for you. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_STRING_OPT_CHAR_INIT + // Defined as 0 or 1. Default is 1. + // Defines if newly created characters are initialized to 0 or left + // as random values. + // The C++ string standard is to initialize chars to 0. + #define EASTL_STRING_OPT_CHAR_INIT 1 +#endif + +#ifndef EASTL_STRING_OPT_EXPLICIT_CTORS + // Defined as 0 or 1. Default is 0. + // Defines if we should implement explicity in constructors where the C++ + // standard string does not. The advantage of enabling explicit constructors + // is that you can do this: string s = "hello"; in addition to string s("hello"); + // The disadvantage of enabling explicity constructors is that there can be + // silent conversions done which impede performance if the user isn't paying + // attention. + // C++ standard string ctors are not explicit. + #define EASTL_STRING_OPT_EXPLICIT_CTORS 0 +#endif + +#ifndef EASTL_STRING_OPT_LENGTH_ERRORS + // Defined as 0 or 1. Default is equal to EASTL_EXCEPTIONS_ENABLED. + // Defines if we check for string values going beyond kMaxSize + // (a very large value) and throw exections if so. + // C++ standard strings are expected to do such checks. + #define EASTL_STRING_OPT_LENGTH_ERRORS EASTL_EXCEPTIONS_ENABLED +#endif + +#ifndef EASTL_STRING_OPT_RANGE_ERRORS + // Defined as 0 or 1. Default is equal to EASTL_EXCEPTIONS_ENABLED. + // Defines if we check for out-of-bounds references to string + // positions and throw exceptions if so. Well-behaved code shouldn't + // refence out-of-bounds positions and so shouldn't need these checks. + // C++ standard strings are expected to do such range checks. + #define EASTL_STRING_OPT_RANGE_ERRORS EASTL_EXCEPTIONS_ENABLED +#endif + +#ifndef EASTL_STRING_OPT_ARGUMENT_ERRORS + // Defined as 0 or 1. Default is 0. + // Defines if we check for NULL ptr arguments passed to string + // functions by the user and throw exceptions if so. Well-behaved code + // shouldn't pass bad arguments and so shouldn't need these checks. + // Also, some users believe that strings should check for NULL pointers + // in all their arguments and do no-ops if so. This is very debatable. + // C++ standard strings are not required to check for such argument errors. + #define EASTL_STRING_OPT_ARGUMENT_ERRORS 0 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ABSTRACT_STRING_ENABLED +// +// Defined as 0 or 1. Default is 0 until abstract string is fully tested. +// Defines whether the proposed replacement for the string module is enabled. +// See bonus/abstract_string.h for more information. +// +#ifndef EASTL_ABSTRACT_STRING_ENABLED + #define EASTL_ABSTRACT_STRING_ENABLED 0 +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_BITSET_SIZE_T +// +// Defined as 0 or 1. Default is 1. +// Controls whether bitset uses size_t or eastl_size_t. +// +#ifndef EASTL_BITSET_SIZE_T + #define EASTL_BITSET_SIZE_T 1 +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_LIST_SIZE_CACHE +// +// Defined as 0 or 1. Default is 0. +// If defined as 1, the list and slist containers (and possibly any additional +// containers as well) keep a member mSize (or similar) variable which allows +// the size() member function to execute in constant time (a.k.a. O(1)). +// There are debates on both sides as to whether it is better to have this +// cached value or not, as having it entails some cost (memory and code). +// To consider: Make list size caching an optional template parameter. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_LIST_SIZE_CACHE + #define EASTL_LIST_SIZE_CACHE 0 +#endif + +#ifndef EASTL_SLIST_SIZE_CACHE + #define EASTL_SLIST_SIZE_CACHE 0 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_MAX_STACK_USAGE +// +// Defined as an integer greater than zero. Default is 4000. +// There are some places in EASTL where temporary objects are put on the +// stack. A common example of this is in the implementation of container +// swap functions whereby a temporary copy of the container is made. +// There is a problem, however, if the size of the item created on the stack +// is very large. This can happen with fixed-size containers, for example. +// The EASTL_MAX_STACK_USAGE define specifies the maximum amount of memory +// (in bytes) that the given platform/compiler will safely allow on the stack. +// Platforms such as Windows will generally allow larger values than embedded +// systems or console machines, but it is usually a good idea to stick with +// a max usage value that is portable across all platforms, lest the user be +// surprised when something breaks as it is ported to another platform. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_MAX_STACK_USAGE + #define EASTL_MAX_STACK_USAGE 4000 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_VA_COPY_ENABLED +// +// Defined as 0 or 1. Default is 1 for compilers that need it, 0 for others. +// Some compilers on some platforms implement va_list whereby its contents +// are destroyed upon usage, even if passed by value to another function. +// With these compilers you can use va_copy to restore the a va_list. +// Known compiler/platforms that destroy va_list contents upon usage include: +// CodeWarrior on PowerPC +// GCC on x86-64 +// However, va_copy is part of the C99 standard and not part of earlier C and +// C++ standards. So not all compilers support it. VC++ doesn't support va_copy, +// but it turns out that VC++ doesn't need it on the platforms it supports. +// For example usage, see the EASTL string.h file. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_VA_COPY_ENABLED + #if defined(__MWERKS__) || (defined(__GNUC__) && (__GNUC__ >= 3) && (!defined(__i386__) || defined(__x86_64__)) && !defined(__ppc__) && !defined(__PPC__) && !defined(__PPC64__)) + #define EASTL_VA_COPY_ENABLED 1 + #else + #define EASTL_VA_COPY_ENABLED 0 + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_LIST_PROXY_ENABLED +// +#if !defined(EASTL_LIST_PROXY_ENABLED) + // GCC with -fstrict-aliasing has bugs (or undocumented functionality in their + // __may_alias__ implementation. The compiler gets confused about function signatures. + // VC8 (1400) doesn't need the proxy because it has built-in smart debugging capabilities. + #if defined(EASTL_DEBUG) && (!defined(__GNUC__) || defined(__SNC__)) && (!defined(_MSC_VER) || (_MSC_VER < 1400)) + #define EASTL_LIST_PROXY_ENABLED 1 + #define EASTL_LIST_PROXY_MAY_ALIAS EASTL_MAY_ALIAS + #else + #define EASTL_LIST_PROXY_ENABLED 0 + #define EASTL_LIST_PROXY_MAY_ALIAS + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_STD_ITERATOR_CATEGORY_ENABLED +// +// Defined as 0 or 1. Default is 1. +// If defined as non-zero, EASTL iterator categories (iterator.h's input_iterator_tag, +// forward_iterator_tag, etc.) are defined to be those from std C++ in the std +// namespace. The reason for wanting to enable such a feature is that it allows +// EASTL containers and algorithms to work with std STL containes and algorithms. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_STD_ITERATOR_CATEGORY_ENABLED + #define EASTL_STD_ITERATOR_CATEGORY_ENABLED 1 +#endif + +#if EASTL_STD_ITERATOR_CATEGORY_ENABLED + #define EASTL_ITC_NS std +#else + #define EASTL_ITC_NS eastl +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_VALIDATION_ENABLED +// +// Defined as an integer >= 0. Default is to be equal to EASTL_DEBUG. +// If nonzero, then a certain amount of automatic runtime validation is done. +// Runtime validation is not considered the same thing as asserting that user +// input values are valid. Validation refers to internal consistency checking +// of the validity of containers and their iterators. Validation checking is +// something that often involves significantly more than basic assertion +// checking, and it may sometimes be desirable to disable it. +// This macro would generally be used internally by EASTL. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_VALIDATION_ENABLED + #define EASTL_VALIDATION_ENABLED EASTL_DEBUG +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_VALIDATE_COMPARE +// +// Defined as EASTL_ASSERT or defined away. Default is EASTL_ASSERT if EASTL_VALIDATION_ENABLED is enabled. +// This is used to validate user-supplied comparison functions, particularly for sorting purposes. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_VALIDATE_COMPARE_ENABLED + #define EASTL_VALIDATE_COMPARE_ENABLED EASTL_VALIDATION_ENABLED +#endif + +#if EASTL_VALIDATE_COMPARE_ENABLED + #define EASTL_VALIDATE_COMPARE EASTL_ASSERT +#else + #define EASTL_VALIDATE_COMPARE(expression) +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_VALIDATE_INTRUSIVE_LIST +// +// Defined as an integral value >= 0. Controls the amount of automatic validation +// done by intrusive_list. A value of 0 means no automatic validation is done. +// As of this writing, EASTL_VALIDATE_INTRUSIVE_LIST defaults to 0, as it makes +// the intrusive_list_node become a non-POD, which may be an issue for some code. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_VALIDATE_INTRUSIVE_LIST + #define EASTL_VALIDATE_INTRUSIVE_LIST 0 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_FORCE_INLINE +// +// Defined as a "force inline" expression or defined away. +// You generally don't need to use forced inlining with the Microsoft and +// Metrowerks compilers, but you may need it with the GCC compiler (any version). +// +// Example usage: +// template +// EASTL_FORCE_INLINE typename vector::size_type +// vector::size() const +// { return mpEnd - mpBegin; } +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_FORCE_INLINE + #define EASTL_FORCE_INLINE EA_FORCE_INLINE +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_MAY_ALIAS +// +// Defined as a macro that wraps the GCC may_alias attribute. This attribute +// has no significance for VC++ because VC++ doesn't support the concept of +// strict aliasing. Users should avoid writing code that breaks strict +// aliasing rules; EASTL_MAY_ALIAS is for cases with no alternative. +// +// Example usage: +// uint32_t value EASTL_MAY_ALIAS; +// +// Example usage: +// typedef uint32_t EASTL_MAY_ALIAS value_type; +// value_type value; +// +#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 303) + #define EASTL_MAY_ALIAS __attribute__((__may_alias__)) +#else + #define EASTL_MAY_ALIAS +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_LIKELY / EASTL_UNLIKELY +// +// Defined as a macro which gives a hint to the compiler for branch +// prediction. GCC gives you the ability to manually give a hint to +// the compiler about the result of a comparison, though it's often +// best to compile shipping code with profiling feedback under both +// GCC (-fprofile-arcs) and VC++ (/LTCG:PGO, etc.). However, there +// are times when you feel very sure that a boolean expression will +// usually evaluate to either true or false and can help the compiler +// by using an explicity directive... +// +// Example usage: +// if(EASTL_LIKELY(a == 0)) // Tell the compiler that a will usually equal 0. +// { ... } +// +// Example usage: +// if(EASTL_UNLIKELY(a == 0)) // Tell the compiler that a will usually not equal 0. +// { ... } +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_LIKELY + #if defined(__GNUC__) && (__GNUC__ >= 3) + #define EASTL_LIKELY(x) __builtin_expect(!!(x), true) + #define EASTL_UNLIKELY(x) __builtin_expect(!!(x), false) + #else + #define EASTL_LIKELY(x) (x) + #define EASTL_UNLIKELY(x) (x) + #endif +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_MINMAX_ENABLED +// +// Defined as 0 or 1; default is 1. +// Specifies whether the min and max algorithms are available. +// It may be useful to disable the min and max algorithems because sometimes +// #defines for min and max exist which would collide with EASTL min and max. +// Note that there are already alternative versions of min and max in EASTL +// with the min_alt and max_alt functions. You can use these without colliding +// with min/max macros that may exist. +// +/////////////////////////////////////////////////////////////////////////////// +#ifndef EASTL_MINMAX_ENABLED + #define EASTL_MINMAX_ENABLED 1 +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_NOMINMAX +// +// Defined as 0 or 1; default is 1. +// MSVC++ has #defines for min/max which collide with the min/max algorithm +// declarations. If EASTL_NOMINMAX is defined as 1, then we undefine min and +// max if they are #defined by an external library. This allows our min and +// max definitions in algorithm.h to work as expected. An alternative to +// the enabling of EASTL_NOMINMAX is to #define NOMINMAX in your project +// settings if you are compiling for Windows. +// Note that this does not control the availability of the EASTL min and max +// algorithms; the EASTL_MINMAX_ENABLED configuration parameter does that. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_NOMINMAX + #define EASTL_NOMINMAX 1 +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ALIGN_OF +// +// Determines the alignment of a type. +// +// Example usage: +// size_t alignment = EASTL_ALIGN_OF(int); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ALIGN_OF + #if defined(__MWERKS__) + #define EASTL_ALIGN_OF(type) ((size_t)__alignof__(type)) + #elif !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x doesn't do __alignof correctly all the time. + #define EASTL_ALIGN_OF __alignof + #else + #define EASTL_ALIGN_OF(type) ((size_t)offsetof(struct{ char c; type m; }, m)) + #endif +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// eastl_size_t +// +// Defined as an unsigned integer type, usually either size_t or uint32_t. +// Defaults to uint32_t instead of size_t because the latter wastes memory +// and is sometimes slower on 64 bit machines. +// +// Example usage: +// eastl_size_t n = intVector.size(); +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_SIZE_T + #if(EA_PLATFORM_WORD_SIZE == 4) // If (sizeof(size_t) == 4) and we can thus use size_t as-is... + #include + #define EASTL_SIZE_T size_t + #define EASTL_SSIZE_T intptr_t + #else + #define EASTL_SIZE_T uint32_t + #define EASTL_SSIZE_T int32_t + #endif +#endif + +typedef EASTL_SIZE_T eastl_size_t; // Same concept as std::size_t. +typedef EASTL_SSIZE_T eastl_ssize_t; // Signed version of eastl_size_t. Concept is similar to Posix's ssize_t. + + + + + + +/////////////////////////////////////////////////////////////////////////////// +// AddRef / Release +// +// AddRef and Release are used for "intrusive" reference counting. By the term +// "intrusive", we mean that the reference count is maintained by the object +// and not by the user of the object. Given that an object implements referencing +// counting, the user of the object needs to be able to increment and decrement +// that reference count. We do that via the venerable AddRef and Release functions +// which the object must supply. These defines here allow us to specify the name +// of the functions. They could just as well be defined to addref and delref or +// IncRef and DecRef. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTLAddRef + #define EASTLAddRef AddRef +#endif + +#ifndef EASTLRelease + #define EASTLRelease Release +#endif + + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_ALLOCATOR_EXPLICIT_ENABLED +// +// Defined as 0 or 1. Default is 0 for now but ideally would be changed to +// 1 some day. It's 0 because setting it to 1 breaks some existing code. +// This option enables the allocator ctor to be explicit, which avoids +// some undesirable silent conversions, especially with the string class. +// +// Example usage: +// class allocator +// { +// public: +// EASTL_ALLOCATOR_EXPLICIT allocator(const char* pName); +// }; +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef EASTL_ALLOCATOR_EXPLICIT_ENABLED + #define EASTL_ALLOCATOR_EXPLICIT_ENABLED 0 +#endif + +#if EASTL_ALLOCATOR_EXPLICIT_ENABLED + #define EASTL_ALLOCATOR_EXPLICIT explicit +#else + #define EASTL_ALLOCATOR_EXPLICIT +#endif + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL allocator +// +// The EASTL allocator system allows you to redefine how memory is allocated +// via some defines that are set up here. In the container code, memory is +// allocated via macros which expand to whatever the user has them set to +// expand to. Given that there are multiple allocator systems available, +// this system allows you to configure it to use whatever system you want, +// provided your system meets the requirements of this library. +// The requirements are: +// +// - Must be constructable via a const char* (name) parameter. +// Some uses of allocators won't require this, however. +// - Allocate a block of memory of size n and debug name string. +// - Allocate a block of memory of size n, debug name string, +// alignment a, and offset o. +// - Free memory allocated via either of the allocation functions above. +// - Provide a default allocator instance which can be used if the user +// doesn't provide a specific one. +// +/////////////////////////////////////////////////////////////////////////////// + +// namespace eastl +// { +// class allocator +// { +// allocator(const char* pName = NULL); +// +// void* allocate(size_t n, int flags = 0); +// void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0); +// void deallocate(void* p, size_t n); +// +// const char* get_name() const; +// void set_name(const char* pName); +// }; +// +// allocator* GetDefaultAllocator(); // This is used for anonymous allocations. +// } + +#ifndef EASTLAlloc // To consider: Instead of calling through pAllocator, just go directly to operator new, since that's what allocator does. + #define EASTLAlloc(allocator, n) (allocator).allocate(n); +#endif + +#ifndef EASTLAllocFlags // To consider: Instead of calling through pAllocator, just go directly to operator new, since that's what allocator does. + #define EASTLAllocFlags(allocator, n, flags) (allocator).allocate(n, flags); +#endif + +#ifndef EASTLAllocAligned + #define EASTLAllocAligned(allocator, n, alignment, offset) (allocator).allocate((n), (alignment), (offset)) +#endif + +#ifndef EASTLFree + #define EASTLFree(allocator, p, size) (allocator).deallocate((p), (size)) +#endif + +#ifndef EASTLAllocatorType + #define EASTLAllocatorType eastl::allocator +#endif + +#ifndef EASTLAllocatorDefault + // EASTLAllocatorDefault returns the default allocator instance. This is not a global + // allocator which implements all container allocations but is the allocator that is + // used when EASTL needs to allocate memory internally. There are very few cases where + // EASTL allocates memory internally, and in each of these it is for a sensible reason + // that is documented to behave as such. + #define EASTLAllocatorDefault eastl::GetDefaultAllocator +#endif + + + + + + + + +#endif // Header include guard + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/eastl_rw.h b/lib/eastl/include/EASTL/internal/eastl_rw.h new file mode 100644 index 0000000..d0bf15a --- /dev/null +++ b/lib/eastl/include/EASTL/internal/eastl_rw.h @@ -0,0 +1,47 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// To use this file, you can either copy and paste its contents right below +// the EASTL_USER_CONFIG_HEADER section of EASTL's config.h or you can leave +// config.h unmodified and instead #define EASTL_USER_CONFIG_HEADER be +// config_rw.h and config.h will #include this file automatically. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_RW_H +#define EASTL_RW_H + +// Unused + +#endif // Header include guard + + + + + diff --git a/lib/eastl/include/EASTL/internal/fixed_pool.h b/lib/eastl/include/EASTL/internal/fixed_pool.h new file mode 100644 index 0000000..9aff467 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/fixed_pool.h @@ -0,0 +1,1396 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/fixed_pool.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements the following +// aligned_buffer +// fixed_pool_base +// fixed_pool +// fixed_pool_with_overflow +// fixed_hashtable_allocator +// fixed_vector_allocator +// fixed_swap +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_FIXED_POOL_H +#define EASTL_INTERNAL_FIXED_POOL_H + + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) + #include + #pragma warning(pop) +#else + #include +#endif + + + +namespace eastl +{ + + /// EASTL_FIXED_POOL_DEFAULT_NAME + /// + /// Defines a default allocator name in the absence of a user-provided name. + /// + #ifndef EASTL_FIXED_POOL_DEFAULT_NAME + #define EASTL_FIXED_POOL_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_pool" // Unless the user overrides something, this is "EASTL fixed_pool". + #endif + + + + /////////////////////////////////////////////////////////////////////////// + // aligned_buffer + /////////////////////////////////////////////////////////////////////////// + + /// aligned_buffer + /// + /// This is useful for creating a buffer of the same size and alignment + /// of a given struct or class. This is useful for creating memory pools + /// that support both size and alignment requirements of stored objects + /// but without wasting space in over-allocating. + /// + /// Note that we implement this via struct specializations, as some + /// compilers such as VC++ do not support specification of alignments + /// in any way other than via an integral constant. + /// + /// Example usage: + /// struct Widget{ }; // This class has a given size and alignment. + /// + /// Declare a char buffer of equal size and alignment to Widget. + /// aligned_buffer mWidgetBuffer; + /// + /// Declare an array this time. + /// aligned_buffer mWidgetArray[15]; + /// + typedef char EASTL_MAY_ALIAS aligned_buffer_char; + + template + struct aligned_buffer { aligned_buffer_char buffer[size]; }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(2) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(2); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(4) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(4); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(8) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(8); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(16) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(16); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(32) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(32); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(64) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(64); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(128) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(128); }; + + #if !defined(EA_PLATFORM_PSP) // This compiler fails to compile alignment >= 256 and gives an error. + + template + struct aligned_buffer { EA_PREFIX_ALIGN(256) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(256); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(512) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(512); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(1024) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(1024); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(2048) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(2048); }; + + template + struct aligned_buffer { EA_PREFIX_ALIGN(4096) aligned_buffer_char buffer[size] EA_POSTFIX_ALIGN(4096); }; + + #endif // EA_PLATFORM_PSP + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_pool_base + /////////////////////////////////////////////////////////////////////////// + + /// fixed_pool_base + /// + /// This is a base class for the implementation of fixed-size pools. + /// In particular, the fixed_pool and fixed_pool_with_overflow classes + /// are based on fixed_pool_base. + /// + struct EASTL_API fixed_pool_base + { + public: + /// fixed_pool_base + /// + fixed_pool_base(void* pMemory = NULL) + : mpHead((Link*)pMemory) + , mpNext((Link*)pMemory) + , mpCapacity((Link*)pMemory) + #if EASTL_DEBUG + , mnNodeSize(0) // This is normally set in the init function. + #endif + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + mnCurrentSize = 0; + mnPeakSize = 0; + #endif + } + + + /// operator= + /// + fixed_pool_base& operator=(const fixed_pool_base&) + { + // By design we do nothing. We don't attempt to deep-copy member data. + return *this; + } + + + /// init + /// + /// Initializes a fixed_pool with a given set of parameters. + /// You cannot call this function twice else the resulting + /// behaviour will be undefined. You can only call this function + /// after constructing the fixed_pool with the default constructor. + /// + void init(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t alignmentOffset = 0); + + + /// peak_size + /// + /// Returns the maximum number of outstanding allocations there have been + /// at any one time. This represents a high water mark for the allocation count. + /// + size_t peak_size() const + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + return mnPeakSize; + #else + return 0; + #endif + } + + + /// can_allocate + /// + /// Returns true if there are any free links. + /// + bool can_allocate() const + { + return (mpHead != NULL) || (mpNext != mpCapacity); + } + + public: + /// Link + /// Implements a singly-linked list. + struct Link + { + Link* mpNext; + }; + + Link* mpHead; + Link* mpNext; + Link* mpCapacity; + size_t mnNodeSize; + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + uint32_t mnCurrentSize; /// Current number of allocated nodes. + uint32_t mnPeakSize; /// Max number of allocated nodes at any one time. + #endif + + }; // fixed_pool_base + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_pool + /////////////////////////////////////////////////////////////////////////// + + /// fixed_pool + /// + /// Implements a simple fixed pool allocator for use by fixed-size containers. + /// This is not a generic eastl allocator which can be plugged into an arbitrary + /// eastl container, as it simplifies some functions are arguments for the + /// purpose of efficiency. + /// + class EASTL_API fixed_pool : public fixed_pool_base + { + public: + /// fixed_pool + /// + /// Default constructor. User usually will want to call init() after + /// constructing via this constructor. The pMemory argument is for the + /// purposes of temporarily storing a pointer to the buffer to be used. + /// Even though init may have a pMemory argument, this arg is useful + /// for temporary storage, as per copy construction. + /// + fixed_pool(void* pMemory = NULL) + : fixed_pool_base(pMemory) + { + } + + + /// fixed_pool + /// + /// Constructs a fixed_pool with a given set of parameters. + /// + fixed_pool(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t alignmentOffset = 0) + { + init(pMemory, memorySize, nodeSize, alignment, alignmentOffset); + } + + + /// operator= + /// + fixed_pool& operator=(const fixed_pool&) + { + // By design we do nothing. We don't attempt to deep-copy member data. + return *this; + } + + + /// allocate + /// + /// Allocates a new object of the size specified upon class initialization. + /// Returns NULL if there is no more memory. + /// + void* allocate() + { + Link* pLink = mpHead; + + if(pLink) // If we have space... + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(++mnCurrentSize > mnPeakSize) + mnPeakSize = mnCurrentSize; + #endif + + mpHead = pLink->mpNext; + return pLink; + } + else + { + // If there's no free node in the free list, just + // allocate another from the reserved memory area + + if(mpNext != mpCapacity) + { + pLink = mpNext; + + mpNext = reinterpret_cast(reinterpret_cast(mpNext) + mnNodeSize); + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(++mnCurrentSize > mnPeakSize) + mnPeakSize = mnCurrentSize; + #endif + + return pLink; + } + + // EASTL_ASSERT(false); To consider: enable this assert. However, we intentionally disable it because this isn't necessarily an assertable error. + return NULL; + } + } + + + /// deallocate + /// + /// Frees the given object which was allocated by allocate(). + /// If the given node was not allocated by allocate() then the behaviour + /// is undefined. + /// + void deallocate(void* p) + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + --mnCurrentSize; + #endif + + ((Link*)p)->mpNext = mpHead; + mpHead = ((Link*)p); + } + + + using fixed_pool_base::can_allocate; + + + const char* get_name() const + { + return EASTL_FIXED_POOL_DEFAULT_NAME; + } + + + void set_name(const char*) + { + // Nothing to do. We don't allocate memory. + } + + }; // fixed_pool + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_pool_with_overflow + /////////////////////////////////////////////////////////////////////////// + + /// fixed_pool_with_overflow + /// + template + class fixed_pool_with_overflow : public fixed_pool_base + { + public: + fixed_pool_with_overflow(void* pMemory = NULL) + : fixed_pool_base(pMemory), + mOverflowAllocator(EASTL_FIXED_POOL_DEFAULT_NAME) + { + // Leave mpPoolBegin, mpPoolEnd uninitialized. + } + + + fixed_pool_with_overflow(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t alignmentOffset = 0) + : mOverflowAllocator(EASTL_FIXED_POOL_DEFAULT_NAME) + { + fixed_pool_base::init(pMemory, memorySize, nodeSize, alignment, alignmentOffset); + + mpPoolBegin = pMemory; + } + + + /// operator= + /// + fixed_pool_with_overflow& operator=(const fixed_pool_with_overflow& x) + { + #if EASTL_ALLOCATOR_COPY_ENABLED + mOverflowAllocator = x.mOverflowAllocator; + #else + (void)x; + #endif + + return *this; + } + + + void init(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t alignmentOffset = 0) + { + fixed_pool_base::init(pMemory, memorySize, nodeSize, alignment, alignmentOffset); + + mpPoolBegin = pMemory; + } + + + void* allocate() + { + void* p = NULL; + Link* pLink = mpHead; + + if(pLink) + { + // Unlink from chain + p = pLink; + mpHead = pLink->mpNext; + } + else + { + // If there's no free node in the free list, just + // allocate another from the reserved memory area + + if(mpNext != mpCapacity) + { + p = pLink = mpNext; + mpNext = reinterpret_cast(reinterpret_cast(mpNext) + mnNodeSize); + } + else + p = mOverflowAllocator.allocate(mnNodeSize); + } + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + if(p && (++mnCurrentSize > mnPeakSize)) + mnPeakSize = mnCurrentSize; + #endif + + return p; + } + + + void deallocate(void* p) + { + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + --mnCurrentSize; + #endif + + if((p >= mpPoolBegin) && (p < mpCapacity)) + { + ((Link*)p)->mpNext = mpHead; + mpHead = ((Link*)p); + } + else + mOverflowAllocator.deallocate(p, (size_t)mnNodeSize); + } + + + using fixed_pool_base::can_allocate; + + + const char* get_name() const + { + return mOverflowAllocator.get_name(); + } + + + void set_name(const char* pName) + { + mOverflowAllocator.set_name(pName); + } + + public: + Allocator mOverflowAllocator; + void* mpPoolBegin; // Ideally we wouldn't need this member variable. he problem is that the information about the pool buffer and object size is stored in the owning container and we can't have access to it without increasing the amount of code we need and by templating more code. It may turn out that simply storing data here is smaller in the end. + + }; // fixed_pool_with_overflow + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_node_allocator + /////////////////////////////////////////////////////////////////////////// + + /// fixed_node_allocator + /// + /// Note: This class was previously named fixed_node_pool, but was changed because this name + /// was inconsistent with the other allocators here which ended with _allocator. + /// + /// Implements a fixed_pool with a given node count, alignment, and alignment offset. + /// fixed_node_allocator is like fixed_pool except it is templated on the node type instead + /// of being a generic allocator. All it does is pass allocations through to + /// the fixed_pool base. This functionality is separate from fixed_pool because there + /// are other uses for fixed_pool. + /// + /// We template on kNodeSize instead of node_type because the former allows for the + /// two different node_types of the same size to use the same template implementation. + /// + /// Template parameters: + /// nodeSize The size of the object to allocate. + /// nodeCount The number of objects the pool contains. + /// nodeAlignment The alignment of the objects to allocate. + /// nodeAlignmentOffset The alignment offset of the objects to allocate. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template + class fixed_node_allocator + { + public: + typedef typename type_select, fixed_pool>::type pool_type; + typedef fixed_node_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset + }; + + public: + pool_type mPool; + + public: + //fixed_node_allocator(const char* pName) + //{ + // mPool.set_name(pName); + //} + + + fixed_node_allocator(void* pNodeBuffer) + : mPool(pNodeBuffer, kNodesSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset) + { + } + + + /// fixed_node_allocator + /// + /// Note that we are copying x.mpHead to our own fixed_pool. This at first may seem + /// broken, as fixed pools cannot take over ownership of other fixed pools' memory. + /// However, we declare that this copy ctor can only ever be safely called when + /// the user has intentionally pre-seeded the source with the destination pointer. + /// This is somewhat playing with fire, but it allows us to get around chicken-and-egg + /// problems with containers being their own allocators, without incurring any memory + /// costs or extra code costs. There's another reason for this: we very strongly want + /// to avoid full copying of instances of fixed_pool around, especially via the stack. + /// Larger pools won't even be able to fit on many machine's stacks. So this solution + /// is also a mechanism to prevent that situation from existing and being used. + /// Perhaps some day we'll find a more elegant yet costless way around this. + /// + fixed_node_allocator(const this_type& x) + : mPool(x.mPool.mpNext, kNodesSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset) + { + // Problem: how do we copy mPool.mOverflowAllocator if mPool is fixed_pool_with_overflow? + // Probably we should use mPool = x.mPool, though it seems a little odd to do so after + // doing the copying above. + mPool = x.mPool; + } + + + this_type& operator=(const this_type& x) + { + mPool = x.mPool; + return *this; + } + + + void* allocate(size_t n, int /*flags*/ = 0) + { + (void)n; + EASTL_ASSERT(n == kNodeSize); + return mPool.allocate(); + } + + + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int /*flags*/ = 0) + { + (void)n; + EASTL_ASSERT(n == kNodeSize); + return mPool.allocate(); + } + + + void deallocate(void* p, size_t) + { + mPool.deallocate(p); + } + + + /// can_allocate + /// + /// Returns true if there are any free links. + /// + bool can_allocate() const + { + return mPool.can_allocate(); + } + + + /// reset + /// + /// This function unilaterally resets the fixed pool back to a newly initialized + /// state. This is useful for using in tandem with container reset functionality. + /// + void reset(void* pNodeBuffer) + { + mPool.init(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset); + } + + + const char* get_name() const + { + return mPool.get_name(); + } + + + void set_name(const char* pName) + { + mPool.set_name(pName); + } + + + overflow_allocator_type& get_overflow_allocator() + { + return mPool.mOverflowAllocator; + } + + + void set_overflow_allocator(const overflow_allocator_type& allocator) + { + mPool.mOverflowAllocator = allocator; + } + + }; // fixed_node_allocator + + + // This is a near copy of the code above, with the only difference being + // the 'false' bEnableOverflow template parameter, the pool_type and this_type typedefs, + // and the get_overflow_allocator / set_overflow_allocator functions. + template + class fixed_node_allocator + { + public: + typedef fixed_pool pool_type; + typedef fixed_node_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset + }; + + public: + pool_type mPool; + + public: + fixed_node_allocator(void* pNodeBuffer) + : mPool(pNodeBuffer, kNodesSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset) + { + } + + + fixed_node_allocator(const this_type& x) + : mPool(x.mPool.mpNext, kNodesSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset) + { + } + + + this_type& operator=(const this_type& x) + { + mPool = x.mPool; + return *this; + } + + + void* allocate(size_t n, int /*flags*/ = 0) + { + (void)n; + EASTL_ASSERT(n == kNodeSize); + return mPool.allocate(); + } + + + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int /*flags*/ = 0) + { + (void)n; + EASTL_ASSERT(n == kNodeSize); + return mPool.allocate(); + } + + + void deallocate(void* p, size_t) + { + mPool.deallocate(p); + } + + + bool can_allocate() const + { + return mPool.can_allocate(); + } + + + void reset(void* pNodeBuffer) + { + mPool.init(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset); + } + + + const char* get_name() const + { + return mPool.get_name(); + } + + + void set_name(const char* pName) + { + mPool.set_name(pName); + } + + + overflow_allocator_type& get_overflow_allocator() + { + EASTL_ASSERT(false); + return *(overflow_allocator_type*)NULL; // This is not pretty. + } + + + void set_overflow_allocator(const overflow_allocator_type& /*allocator*/) + { + // We don't have an overflow allocator. + EASTL_ASSERT(false); + } + + }; // fixed_node_allocator + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const fixed_node_allocator& a, + const fixed_node_allocator& b) + { + return (&a == &b); // They are only equal if they are the same object. + } + + + template + inline bool operator!=(const fixed_node_allocator& a, + const fixed_node_allocator& b) + { + return (&a != &b); // They are only equal if they are the same object. + } + + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_hashtable_allocator + /////////////////////////////////////////////////////////////////////////// + + /// fixed_hashtable_allocator + /// + /// Provides a base class for fixed hashtable allocations. + /// To consider: Have this inherit from fixed_node_allocator. + /// + /// Template parameters: + /// bucketCount The fixed number of hashtable buckets to provide. + /// nodeCount The number of objects the pool contains. + /// nodeAlignment The alignment of the objects to allocate. + /// nodeAlignmentOffset The alignment offset of the objects to allocate. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template + class fixed_hashtable_allocator + { + public: + typedef typename type_select, fixed_pool>::type pool_type; + typedef fixed_hashtable_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kBucketCount = bucketCount + 1, // '+1' because the hash table needs a null terminating bucket. + kBucketsSize = bucketCount * sizeof(void*), + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, // Don't need to include kBucketsSize in this calculation, as fixed_hash_xxx containers have a separate buffer for buckets. + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset, + kAllocFlagBuckets = 0x00400000 // Flag to allocator which indicates that we are allocating buckets and not nodes. + }; + + protected: + pool_type mPool; + void* mpBucketBuffer; + + public: + //fixed_hashtable_allocator(const char* pName) + //{ + // mPool.set_name(pName); + //} + + fixed_hashtable_allocator(void* pNodeBuffer) + : mPool(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(NULL) + { + // EASTL_ASSERT(false); // As it stands now, this is not supposed to be called. + } + + + fixed_hashtable_allocator(void* pNodeBuffer, void* pBucketBuffer) + : mPool(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(pBucketBuffer) + { + } + + + /// fixed_hashtable_allocator + /// + /// Note that we are copying x.mpHead and mpBucketBuffer to our own fixed_pool. + /// See the discussion above in fixed_node_allocator for important information about this. + /// + fixed_hashtable_allocator(const this_type& x) + : mPool(x.mPool.mpHead, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(x.mpBucketBuffer) + { + // Problem: how do we copy mPool.mOverflowAllocator if mPool is fixed_pool_with_overflow? + // Probably we should use mPool = x.mPool, though it seems a little odd to do so after + // doing the copying above. + mPool = x.mPool; + } + + + fixed_hashtable_allocator& operator=(const fixed_hashtable_allocator& x) + { + mPool = x.mPool; + return *this; // Do nothing. Ignore the source type. + } + + + void* allocate(size_t n, int flags = 0) + { + // We expect that the caller uses kAllocFlagBuckets when it wants us to allocate buckets instead of nodes. + EASTL_CT_ASSERT(kAllocFlagBuckets == 0x00400000); // Currently we expect this to be so, because the hashtable has a copy of this enum. + if((flags & kAllocFlagBuckets) == 0) // If we are allocating nodes and (probably) not buckets... + { + EASTL_ASSERT(n == kNodeSize); (void)n; // Make unused var warning go away. + return mPool.allocate(); + } + + EASTL_ASSERT(n <= kBucketsSize); + return mpBucketBuffer; + } + + + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int flags = 0) + { + // We expect that the caller uses kAllocFlagBuckets when it wants us to allocate buckets instead of nodes. + if((flags & kAllocFlagBuckets) == 0) // If we are allocating nodes and (probably) not buckets... + { + EASTL_ASSERT(n == kNodeSize); (void)n; // Make unused var warning go away. + return mPool.allocate(); + } + + // To consider: allow for bucket allocations to overflow. + EASTL_ASSERT(n <= kBucketsSize); + return mpBucketBuffer; + } + + + void deallocate(void* p, size_t) + { + if(p != mpBucketBuffer) // If we are freeing a node and not buckets... + mPool.deallocate(p); + } + + + bool can_allocate() const + { + return mPool.can_allocate(); + } + + + void reset(void* pNodeBuffer) + { + // No need to modify mpBucketBuffer, as that is constant. + mPool.init(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset); + } + + + const char* get_name() const + { + return mPool.get_name(); + } + + + void set_name(const char* pName) + { + mPool.set_name(pName); + } + + + overflow_allocator_type& get_overflow_allocator() + { + return mPool.mOverflowAllocator; + } + + + void set_overflow_allocator(const overflow_allocator_type& allocator) + { + mPool.mOverflowAllocator = allocator; + } + + }; // fixed_hashtable_allocator + + + // This is a near copy of the code above, with the only difference being + // the 'false' bEnableOverflow template parameter, the pool_type and this_type typedefs, + // and the get_overflow_allocator / set_overflow_allocator functions. + template + class fixed_hashtable_allocator + { + public: + typedef fixed_pool pool_type; + typedef fixed_hashtable_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kBucketCount = bucketCount + 1, // '+1' because the hash table needs a null terminating bucket. + kBucketsSize = bucketCount * sizeof(void*), + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, // Don't need to include kBucketsSize in this calculation, as fixed_hash_xxx containers have a separate buffer for buckets. + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset, + kAllocFlagBuckets = 0x00400000 // Flag to allocator which indicates that we are allocating buckets and not nodes. + }; + + protected: + pool_type mPool; + void* mpBucketBuffer; + + public: + //fixed_hashtable_allocator(const char* pName) + //{ + // mPool.set_name(pName); + //} + + fixed_hashtable_allocator(void* pNodeBuffer) + : mPool(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(NULL) + { + // EASTL_ASSERT(false); // As it stands now, this is not supposed to be called. + } + + + fixed_hashtable_allocator(void* pNodeBuffer, void* pBucketBuffer) + : mPool(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(pBucketBuffer) + { + } + + + /// fixed_hashtable_allocator + /// + /// Note that we are copying x.mpHead and mpBucketBuffer to our own fixed_pool. + /// See the discussion above in fixed_node_allocator for important information about this. + /// + fixed_hashtable_allocator(const this_type& x) + : mPool(x.mPool.mpHead, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset), + mpBucketBuffer(x.mpBucketBuffer) + { + } + + + fixed_hashtable_allocator& operator=(const fixed_hashtable_allocator& x) + { + mPool = x.mPool; + return *this; // Do nothing. Ignore the source type. + } + + + void* allocate(size_t n, int flags = 0) + { + // We expect that the caller uses kAllocFlagBuckets when it wants us to allocate buckets instead of nodes. + EASTL_CT_ASSERT(kAllocFlagBuckets == 0x00400000); // Currently we expect this to be so, because the hashtable has a copy of this enum. + if((flags & kAllocFlagBuckets) == 0) // If we are allocating nodes and (probably) not buckets... + { + EASTL_ASSERT(n == kNodeSize); (void)n; // Make unused var warning go away. + return mPool.allocate(); + } + + EASTL_ASSERT(n <= kBucketsSize); + return mpBucketBuffer; + } + + + void* allocate(size_t n, size_t /*alignment*/, size_t /*offset*/, int flags = 0) + { + // We expect that the caller uses kAllocFlagBuckets when it wants us to allocate buckets instead of nodes. + if((flags & kAllocFlagBuckets) == 0) // If we are allocating nodes and (probably) not buckets... + { + EASTL_ASSERT(n == kNodeSize); (void)n; // Make unused var warning go away. + return mPool.allocate(); + } + + // To consider: allow for bucket allocations to overflow. + EASTL_ASSERT(n <= kBucketsSize); + return mpBucketBuffer; + } + + + void deallocate(void* p, size_t) + { + if(p != mpBucketBuffer) // If we are freeing a node and not buckets... + mPool.deallocate(p); + } + + + bool can_allocate() const + { + return mPool.can_allocate(); + } + + + void reset(void* pNodeBuffer) + { + // No need to modify mpBucketBuffer, as that is constant. + mPool.init(pNodeBuffer, kBufferSize, kNodeSize, kNodeAlignment, kNodeAlignmentOffset); + } + + + const char* get_name() const + { + return mPool.get_name(); + } + + + void set_name(const char* pName) + { + mPool.set_name(pName); + } + + + overflow_allocator_type& get_overflow_allocator() + { + EASTL_ASSERT(false); + return *(overflow_allocator_type*)NULL; // This is not pretty. + } + + void set_overflow_allocator(const overflow_allocator_type& /*allocator*/) + { + // We don't have an overflow allocator. + EASTL_ASSERT(false); + } + + }; // fixed_hashtable_allocator + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const fixed_hashtable_allocator& a, + const fixed_hashtable_allocator& b) + { + return (&a == &b); // They are only equal if they are the same object. + } + + + template + inline bool operator!=(const fixed_hashtable_allocator& a, + const fixed_hashtable_allocator& b) + { + return (&a != &b); // They are only equal if they are the same object. + } + + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_vector_allocator + /////////////////////////////////////////////////////////////////////////// + + /// fixed_vector_allocator + /// + /// Template parameters: + /// nodeSize The size of individual objects. + /// nodeCount The number of objects the pool contains. + /// nodeAlignment The alignment of the objects to allocate. + /// nodeAlignmentOffset The alignment offset of the objects to allocate. + /// bEnableOverflow Whether or not we should use the overflow heap if our object pool is exhausted. + /// Allocator Overflow allocator, which is only used if bEnableOverflow == true. Defaults to the global heap. + /// + template + class fixed_vector_allocator + { + public: + typedef fixed_vector_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset + }; + + public: + overflow_allocator_type mOverflowAllocator; + void* mpPoolBegin; // To consider: Find some way to make this data unnecessary, without increasing template proliferation. + + public: + //fixed_vector_allocator(const char* pName = NULL) + //{ + // mOverflowAllocator.set_name(pName); + //} + + fixed_vector_allocator(void* pNodeBuffer) + : mpPoolBegin(pNodeBuffer) + { + } + + fixed_vector_allocator& operator=(const fixed_vector_allocator& x) + { + #if EASTL_ALLOCATOR_COPY_ENABLED + mOverflowAllocator = x.mOverflowAllocator; + #else + (void)x; + #endif + + return *this; // Do nothing. Ignore the source type. + } + + void* allocate(size_t n, int flags = 0) + { + return mOverflowAllocator.allocate(n, flags); + } + + void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0) + { + return mOverflowAllocator.allocate(n, alignment, offset, flags); + } + + void deallocate(void* p, size_t n) + { + if(p != mpPoolBegin) + mOverflowAllocator.deallocate(p, n); // Can't do this to our own allocation. + } + + const char* get_name() const + { + return mOverflowAllocator.get_name(); + } + + void set_name(const char* pName) + { + mOverflowAllocator.set_name(pName); + } + + overflow_allocator_type& get_overflow_allocator() + { + return mOverflowAllocator; + } + + void set_overflow_allocator(const overflow_allocator_type& allocator) + { + mOverflowAllocator = allocator; + } + + }; // fixed_vector_allocator + + + template + class fixed_vector_allocator + { + public: + typedef fixed_vector_allocator this_type; + typedef Allocator overflow_allocator_type; + + enum + { + kNodeSize = nodeSize, + kNodeCount = nodeCount, + kNodesSize = nodeCount * nodeSize, // Note that the kBufferSize calculation assumes that the compiler sets sizeof(T) to be a multiple alignof(T), and so sizeof(T) is always >= alignof(T). + kBufferSize = kNodesSize + ((nodeAlignment > 1) ? nodeSize-1 : 0) + nodeAlignmentOffset, + kNodeAlignment = nodeAlignment, + kNodeAlignmentOffset = nodeAlignmentOffset + }; + + //fixed_vector_allocator(const char* = NULL) // This char* parameter is present so that this class can be like the other version. + //{ + //} + + fixed_vector_allocator(void* /*pNodeBuffer*/) + { + } + + void* allocate(size_t /*n*/, int /*flags*/ = 0) + { + EASTL_ASSERT(false); // A fixed_vector should not reallocate, else the user has exhausted its space. + return NULL; + } + + void* allocate(size_t /*n*/, size_t /*alignment*/, size_t /*offset*/, int /*flags*/ = 0) + { + EASTL_ASSERT(false); + return NULL; + } + + void deallocate(void* /*p*/, size_t /*n*/) + { + } + + const char* get_name() const + { + return EASTL_FIXED_POOL_DEFAULT_NAME; + } + + void set_name(const char* /*pName*/) + { + } + + overflow_allocator_type& get_overflow_allocator() + { + EASTL_ASSERT(false); + overflow_allocator_type* pNULL = NULL; + return *pNULL; // This is not pretty, but it should never execute. + } + + void set_overflow_allocator(const overflow_allocator_type& /*allocator*/) + { + // We don't have an overflow allocator. + EASTL_ASSERT(false); + } + + }; // fixed_vector_allocator + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const fixed_vector_allocator& a, + const fixed_vector_allocator& b) + { + return (&a == &b); // They are only equal if they are the same object. + } + + + template + inline bool operator!=(const fixed_vector_allocator& a, + const fixed_vector_allocator& b) + { + return (&a != &b); // They are only equal if they are the same object. + } + + + + + + /////////////////////////////////////////////////////////////////////////// + // fixed_swap + /////////////////////////////////////////////////////////////////////////// + + /// fixed_swap + /// + /// This function implements a swap suitable for fixed containers. + /// This is an issue because the size of fixed containers can be very + /// large, due to their having the container buffer within themselves. + /// Note that we are referring to sizeof(container) and not the total + /// sum of memory allocated by the container from the heap. + /// + template + void fixed_swap(Container& a, Container& b) + { + // We must do a brute-force swap, because fixed containers cannot share memory allocations. + eastl::less compare; + + if(compare(sizeof(a), EASTL_MAX_STACK_USAGE)) // Using compare instead of just '<' avoids a stubborn compiler warning. + { + // Note: The C++ language does not define what happens when you declare + // an object in too small of stack space but the object is never created. + // This may result in a stack overflow exception on some systems, depending + // on how they work and possibly depending on enabled debug functionality. + + const Container temp(a); // Can't use global swap because that could + a = b; // itself call this swap function in return. + b = temp; + } + else + { + EASTLAllocatorType allocator(*EASTLAllocatorDefault(), EASTL_TEMP_DEFAULT_NAME); + void* const pMemory = allocator.allocate(sizeof(a)); + + if(pMemory) + { + Container* const pTemp = ::new(pMemory) Container(a); + a = b; + b = *pTemp; + + pTemp->~Container(); + allocator.deallocate(pMemory, sizeof(a)); + } + } + } + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/generic_iterator.h b/lib/eastl/include/EASTL/internal/generic_iterator.h new file mode 100644 index 0000000..9700b06 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/generic_iterator.h @@ -0,0 +1,242 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/generic_iterator.h +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Implements a generic iterator from a given iteratable type, such as a pointer. +// We cannot put this file into our own iterator.h file because we need to +// still be able to use this file when we have our iterator.h disabled. +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_GENERIC_ITERATOR_H +#define EASTL_INTERNAL_GENERIC_ITERATOR_H + + +#include +#include +#include + + +#ifdef _MSC_VER + #pragma warning(push) // VC++ generates a bogus warning that you cannot code away. + #pragma warning(disable: 4619) // There is no warning number 'number'. + #pragma warning(disable: 4217) // Member template functions cannot be used for copy-assignment or copy-construction. +#endif + + +namespace eastl +{ + + /// generic_iterator + /// + /// Converts something which can be iterated into a formal iterator. + /// While this class' primary purpose is to allow the conversion of + /// a pointer to an iterator, you can convert anything else to an + /// iterator by defining an iterator_traits<> specialization for that + /// object type. See EASTL iterator.h for this. + /// + /// Example usage: + /// typedef generic_iterator IntArrayIterator; + /// typedef generic_iterator IntArrayIteratorOther; + /// + template + class generic_iterator + { + protected: + Iterator mIterator; + + public: + typedef typename eastl::iterator_traits::iterator_category iterator_category; + typedef typename eastl::iterator_traits::value_type value_type; + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::reference reference; + typedef typename eastl::iterator_traits::pointer pointer; + typedef Iterator iterator_type; + typedef Container container_type; + typedef generic_iterator this_type; + + generic_iterator() + : mIterator(iterator_type()) { } + + explicit generic_iterator(const iterator_type& x) + : mIterator(x) { } + + this_type& operator=(const iterator_type& x) + { mIterator = x; return *this; } + + template + generic_iterator(const generic_iterator& x) + : mIterator(x.base()) { } + + reference operator*() const + { return *mIterator; } + + pointer operator->() const + { return mIterator; } + + this_type& operator++() + { ++mIterator; return *this; } + + this_type operator++(int) + { return this_type(mIterator++); } + + this_type& operator--() + { --mIterator; return *this; } + + this_type operator--(int) + { return this_type(mIterator--); } + + reference operator[](const difference_type& n) const + { return mIterator[n]; } + + this_type& operator+=(const difference_type& n) + { mIterator += n; return *this; } + + this_type operator+(const difference_type& n) const + { return this_type(mIterator + n); } + + this_type& operator-=(const difference_type& n) + { mIterator -= n; return *this; } + + this_type operator-(const difference_type& n) const + { return this_type(mIterator - n); } + + const iterator_type& base() const + { return mIterator; } + + }; // class generic_iterator + + + + + + template + inline bool operator==(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() == rhs.base(); } + + template + inline bool operator==(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() == rhs.base(); } + + template + inline bool operator!=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() != rhs.base(); } + + template + inline bool operator!=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() != rhs.base(); } + + template + inline bool operator<(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() < rhs.base(); } + + template + inline bool operator<(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() < rhs.base(); } + + template + inline bool operator>(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() > rhs.base(); } + + template + inline bool operator>(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() > rhs.base(); } + + template + inline bool operator<=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() <= rhs.base(); } + + template + inline bool operator<=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() <= rhs.base(); } + + template + inline bool operator>=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() >= rhs.base(); } + + template + inline bool operator>=(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() >= rhs.base(); } + + template + inline typename generic_iterator::difference_type + operator-(const generic_iterator& lhs, const generic_iterator& rhs) + { return lhs.base() - rhs.base(); } + + template + inline generic_iterator + operator+(typename generic_iterator::difference_type n, const generic_iterator& x) + { return generic_iterator(x.base() + n); } + + + + /// is_generic_iterator + /// + /// Tells if an iterator is one of these generic_iterators. This is useful if you want to + /// write code that uses miscellaneous iterators but wants to tell if they are generic_iterators. + /// A primary reason to do so is that you can get at the pointer within the generic_iterator. + /// + template + struct is_generic_iterator : public false_type { }; + + template + struct is_generic_iterator > : public true_type { }; + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/hashtable.h b/lib/eastl/include/EASTL/internal/hashtable.h new file mode 100644 index 0000000..4a928b2 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/hashtable.h @@ -0,0 +1,2261 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/hashtable.h +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a hashtable, much like the C++ TR1 hash_set/hash_map. +// proposed classes. +// The primary distinctions between this hashtable and TR1 hash tables are: +// - hashtable is savvy to an environment that doesn't have exception handling, +// as is sometimes the case with console or embedded environments. +// - hashtable is slightly more space-efficient than a conventional std hashtable +// implementation on platforms with 64 bit size_t. This is +// because std STL uses size_t (64 bits) in data structures whereby 32 bits +// of data would be fine. +// - hashtable can contain objects with alignment requirements. TR1 hash tables +// cannot do so without a bit of tedious non-portable effort. +// - hashtable supports debug memory naming natively. +// - hashtable provides a find function that lets you specify a type that is +// different from the hash table key type. This is particularly useful for +// the storing of string objects but finding them by char pointers. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file is currently partially based on the TR1 (technical report 1) +// reference implementation of the hash_set/hash_map C++ classes +// as of about 4/2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_HASHTABLE_H +#define EASTL_INTERNAL_HASHTABLE_H + + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) + #include + #include + #pragma warning(pop) +#else + #include + #include +#endif + +#ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable: 4512) // 'class' : assignment operator could not be generated. + #pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc +#endif + + +namespace eastl +{ + + /// EASTL_HASHTABLE_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_HASHTABLE_DEFAULT_NAME + #define EASTL_HASHTABLE_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hashtable" // Unless the user overrides something, this is "EASTL hashtable". + #endif + + + /// EASTL_HASHTABLE_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_HASHTABLE_DEFAULT_ALLOCATOR + #define EASTL_HASHTABLE_DEFAULT_ALLOCATOR allocator_type(EASTL_HASHTABLE_DEFAULT_NAME) + #endif + + + + /// gpEmptyBucketArray + /// + /// A shared representation of an empty hash table. This is present so that + /// a new empty hashtable allocates no memory. It has two entries, one for + /// the first lone empty (NULL) bucket, and one for the non-NULL trailing sentinel. + /// + extern EASTL_API void* gpEmptyBucketArray[2]; + + + + /// hash_node + /// + /// A hash_node stores an element in a hash table, much like a + /// linked list node stores an element in a linked list. + /// A hash_node additionally can, via template parameter, + /// store a hash code in the node to speed up hash calculations + /// and comparisons in some cases. + /// + template + struct hash_node; + + template + struct hash_node + { + Value mValue; + hash_node* mpNext; + eastl_size_t mnHashCode; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + } EASTL_MAY_ALIAS; + + template + struct hash_node + { + Value mValue; + hash_node* mpNext; + } EASTL_MAY_ALIAS; + + + + /// node_iterator_base + /// + /// Node iterators iterate nodes within a given bucket. + /// + /// We define a base class here because it is shared by both const and + /// non-const iterators. + /// + template + struct node_iterator_base + { + public: + typedef hash_node node_type; + + node_type* mpNode; + + public: + node_iterator_base(node_type* pNode) + : mpNode(pNode) { } + + void increment() + { mpNode = mpNode->mpNext; } + }; + + + + /// node_iterator + /// + /// Node iterators iterate nodes within a given bucket. + /// + /// The bConst parameter defines if the iterator is a const_iterator + /// or an iterator. + /// + template + struct node_iterator : public node_iterator_base + { + public: + typedef node_iterator_base base_type; + typedef node_iterator this_type; + typedef typename base_type::node_type node_type; + typedef Value value_type; + typedef typename type_select::type pointer; + typedef typename type_select::type reference; + typedef ptrdiff_t difference_type; + typedef EASTL_ITC_NS::forward_iterator_tag iterator_category; + + public: + explicit node_iterator(node_type* pNode = NULL) + : base_type(pNode) { } + + node_iterator(const node_iterator& x) + : base_type(x.mpNode) { } + + reference operator*() const + { return base_type::mpNode->mValue; } + + pointer operator->() const + { return &(base_type::mpNode->mValue); } + + node_iterator& operator++() + { base_type::increment(); return *this; } + + node_iterator operator++(int) + { node_iterator temp(*this); base_type::increment(); return temp; } + + }; // node_iterator + + + + /// hashtable_iterator_base + /// + /// A hashtable_iterator iterates the entire hash table and not just + /// nodes within a single bucket. Users in general will use a hash + /// table iterator much more often, as it is much like other container + /// iterators (e.g. vector::iterator). + /// + /// We define a base class here because it is shared by both const and + /// non-const iterators. + /// + template + struct hashtable_iterator_base + { + public: + typedef hash_node node_type; + + public: + // We use public here because it allows the hashtable class to access + // these without a function call, and we are very strongly avoiding + // function calls in this library, as our primary goal is performance + // over correctness and some compilers (e.g. GCC) are terrible at + // inlining and so avoiding function calls is of major importance. + node_type* mpNode; // Current node within current bucket. + node_type** mpBucket; // Current bucket. + + public: + hashtable_iterator_base(node_type* pNode, node_type** pBucket) + : mpNode(pNode), mpBucket(pBucket) { } + + void increment_bucket() + { + ++mpBucket; + while(*mpBucket == NULL) // We store an extra bucket with some non-NULL value at the end + ++mpBucket; // of the bucket array so that finding the end of the bucket + mpNode = *mpBucket; // array is quick and simple. + } + + void increment() + { + mpNode = mpNode->mpNext; + + while(mpNode == NULL) + mpNode = *++mpBucket; + } + + }; // hashtable_iterator_base + + + + + /// hashtable_iterator + /// + /// A hashtable_iterator iterates the entire hash table and not just + /// nodes within a single bucket. Users in general will use a hash + /// table iterator much more often, as it is much like other container + /// iterators (e.g. vector::iterator). + /// + /// The bConst parameter defines if the iterator is a const_iterator + /// or an iterator. + /// + template + struct hashtable_iterator : public hashtable_iterator_base + { + public: + typedef hashtable_iterator_base base_type; + typedef hashtable_iterator this_type; + typedef hashtable_iterator this_type_non_const; + typedef typename base_type::node_type node_type; + typedef Value value_type; + typedef typename type_select::type pointer; + typedef typename type_select::type reference; + typedef ptrdiff_t difference_type; + typedef EASTL_ITC_NS::forward_iterator_tag iterator_category; + + public: + hashtable_iterator(node_type* pNode = NULL, node_type** pBucket = NULL) + : base_type(pNode, pBucket) { } + + hashtable_iterator(node_type** pBucket) + : base_type(*pBucket, pBucket) { } + + hashtable_iterator(const this_type_non_const& x) + : base_type(x.mpNode, x.mpBucket) { } + + reference operator*() const + { return base_type::mpNode->mValue; } + + pointer operator->() const + { return &(base_type::mpNode->mValue); } + + hashtable_iterator& operator++() + { base_type::increment(); return *this; } + + hashtable_iterator operator++(int) + { hashtable_iterator temp(*this); base_type::increment(); return temp; } + + const node_type* get_node() const + { return base_type::mpNode; } + + }; // hashtable_iterator + + + + + /// ht_distance + /// + /// This function returns the same thing as distance() for + /// forward iterators but returns zero for input iterators. + /// The reason why is that input iterators can only be read + /// once, and calling distance() on an input iterator destroys + /// the ability to read it. This ht_distance is used only for + /// optimization and so the code will merely work better with + /// forward iterators that input iterators. + /// + template + inline typename eastl::iterator_traits::difference_type + distance_fw_impl(Iterator /* first */, Iterator /* last */, EASTL_ITC_NS::input_iterator_tag) + { return 0; } + + template + inline typename eastl::iterator_traits::difference_type + distance_fw_impl(Iterator first, Iterator last, EASTL_ITC_NS::forward_iterator_tag) + { return eastl::distance(first, last); } + + template + inline typename eastl::iterator_traits::difference_type + ht_distance(Iterator first, Iterator last) + { + typedef typename eastl::iterator_traits::iterator_category IC; + return distance_fw_impl(first, last, IC()); + } + + + + + /// mod_range_hashing + /// + /// Implements the algorithm for conversion of a number in the range of + /// [0, UINT32_MAX) to the range of [0, BucketCount). + /// + struct mod_range_hashing + { + // Defined as eastl_size_t instead of size_t because the latter + // wastes memory and is sometimes slower on 64 bit machines. + uint32_t operator()(uint32_t r, uint32_t n) const + { return r % n; } + }; + + + /// default_ranged_hash + /// + /// Default ranged hash function H. In principle it should be a + /// function object composed from objects of type H1 and H2 such that + /// h(k, n) = h2(h1(k), n), but that would mean making extra copies of + /// h1 and h2. So instead we'll just use a tag to tell class template + /// hashtable to do that composition. + /// + struct default_ranged_hash{ }; + + + /// prime_rehash_policy + /// + /// Default value for rehash policy. Bucket size is (usually) the + /// smallest prime that keeps the load factor small enough. + /// + struct EASTL_API prime_rehash_policy + { + public: + float mfMaxLoadFactor; + float mfGrowthFactor; + mutable uint32_t mnNextResize; + + public: + prime_rehash_policy(float fMaxLoadFactor = 1.f) + : mfMaxLoadFactor(fMaxLoadFactor), mfGrowthFactor(2.f), mnNextResize(0) { } + + float GetMaxLoadFactor() const + { return mfMaxLoadFactor; } + + /// Return a bucket count no greater than nBucketCountHint, + /// Don't update member variables while at it. + static uint32_t GetPrevBucketCountOnly(uint32_t nBucketCountHint); + + /// Return a bucket count no greater than nBucketCountHint. + /// This function has a side effect of updating mnNextResize. + uint32_t GetPrevBucketCount(uint32_t nBucketCountHint) const; + + /// Return a bucket count no smaller than nBucketCountHint. + /// This function has a side effect of updating mnNextResize. + uint32_t GetNextBucketCount(uint32_t nBucketCountHint) const; + + /// Return a bucket count appropriate for nElementCount elements. + /// This function has a side effect of updating mnNextResize. + uint32_t GetBucketCount(uint32_t nElementCount) const; + + /// nBucketCount is current bucket count, nElementCount is current element count, + /// and nElementAdd is number of elements to be inserted. Do we need + /// to increase bucket count? If so, return pair(true, n), where + /// n is the new bucket count. If not, return pair(false, 0). + eastl::pair + GetRehashRequired(uint32_t nBucketCount, uint32_t nElementCount, uint32_t nElementAdd) const; + }; + + + + + + /////////////////////////////////////////////////////////////////////// + // Base classes for hashtable. We define these base classes because + // in some cases we want to do different things depending on the + // value of a policy class. In some cases the policy class affects + // which member functions and nested typedefs are defined; we handle that + // by specializing base class templates. Several of the base class templates + // need to access other members of class template hashtable, so we use + // the "curiously recurring template pattern" (parent class is templated + // on type of child class) for them. + /////////////////////////////////////////////////////////////////////// + + + /// rehash_base + /// + /// Give hashtable the get_max_load_factor functions if the rehash + /// policy is prime_rehash_policy. + /// + template + struct rehash_base { }; + + template + struct rehash_base + { + // Returns the max load factor, which is the load factor beyond + // which we rebuild the container with a new bucket count. + float get_max_load_factor() const + { + const Hashtable* const pThis = static_cast(this); + return pThis->rehash_policy().GetMaxLoadFactor(); + } + + // If you want to make the hashtable never rehash (resize), + // set the max load factor to be a very high number (e.g. 100000.f). + void set_max_load_factor(float fMaxLoadFactor) + { + Hashtable* const pThis = static_cast(this); + pThis->rehash_policy(prime_rehash_policy(fMaxLoadFactor)); + } + }; + + + + + /// hash_code_base + /// + /// Encapsulates two policy issues that aren't quite orthogonal. + /// (1) The difference between using a ranged hash function and using + /// the combination of a hash function and a range-hashing function. + /// In the former case we don't have such things as hash codes, so + /// we have a dummy type as placeholder. + /// (2) Whether or not we cache hash codes. Caching hash codes is + /// meaningless if we have a ranged hash function. This is because + /// a ranged hash function converts an object directly to its + /// bucket index without ostensibly using a hash code. + /// We also put the key extraction and equality comparison function + /// objects here, for convenience. + /// + template + struct hash_code_base; + + + /// hash_code_base + /// + /// Specialization: ranged hash function, no caching hash codes. + /// H1 and H2 are provided but ignored. We define a dummy hash code type. + /// + template + struct hash_code_base + { + protected: + ExtractKey mExtractKey; // To do: Make this member go away entirely, as it never has any data. + Equal mEqual; // To do: Make this instance use zero space when it is zero size. + H mRangedHash; // To do: Make this instance use zero space when it is zero size + + public: + H1 hash_function() const + { return H1(); } + + Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard + { return mEqual; } // has specified in its hashtable (unordered_*) proposal. + + const Equal& key_eq() const + { return mEqual; } + + Equal& key_eq() + { return mEqual; } + + protected: + typedef void* hash_code_t; + typedef uint32_t bucket_index_t; + + hash_code_base(const ExtractKey& extractKey, const Equal& eq, const H1&, const H2&, const H& h) + : mExtractKey(extractKey), mEqual(eq), mRangedHash(h) { } + + hash_code_t get_hash_code(const Key& /* key */) const + { return NULL; } + + bucket_index_t bucket_index(hash_code_t, uint32_t) const + { return (bucket_index_t)0; } + + bucket_index_t bucket_index(const Key& key, hash_code_t, uint32_t nBucketCount) const + { return (bucket_index_t)mRangedHash(key, nBucketCount); } + + bucket_index_t bucket_index(const hash_node* pNode, uint32_t nBucketCount) const + { return (bucket_index_t)mRangedHash(mExtractKey(pNode->mValue), nBucketCount); } + + bool compare(const Key& key, hash_code_t, hash_node* pNode) const + { return mEqual(key, mExtractKey(pNode->mValue)); } + + void copy_code(hash_node*, const hash_node*) const + { } // Nothing to do. + + void set_code(hash_node* /* pDest */, hash_code_t /* c */) const + { } // Nothing to do. + + void base_swap(hash_code_base& x) + { + eastl::swap(mExtractKey, x.mExtractKey); + eastl::swap(mEqual, x.mEqual); + eastl::swap(mRangedHash, x.mRangedHash); + } + + }; // hash_code_base + + + + // No specialization for ranged hash function while caching hash codes. + // That combination is meaningless, and trying to do it is an error. + + + /// hash_code_base + /// + /// Specialization: ranged hash function, cache hash codes. + /// This combination is meaningless, so we provide only a declaration + /// and no definition. + /// + template + struct hash_code_base; + + + + /// hash_code_base + /// + /// Specialization: hash function and range-hashing function, + /// no caching of hash codes. H is provided but ignored. + /// Provides typedef and accessor required by TR1. + /// + template + struct hash_code_base + { + protected: + ExtractKey mExtractKey; + Equal mEqual; + H1 m_h1; + H2 m_h2; + + public: + typedef H1 hasher; + + H1 hash_function() const + { return m_h1; } + + Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard + { return mEqual; } // has specified in its hashtable (unordered_*) proposal. + + const Equal& key_eq() const + { return mEqual; } + + Equal& key_eq() + { return mEqual; } + + protected: + typedef uint32_t hash_code_t; + typedef uint32_t bucket_index_t; + typedef hash_node node_type; + + hash_code_base(const ExtractKey& ex, const Equal& eq, const H1& h1, const H2& h2, const default_ranged_hash&) + : mExtractKey(ex), mEqual(eq), m_h1(h1), m_h2(h2) { } + + hash_code_t get_hash_code(const Key& key) const + { return (hash_code_t)m_h1(key); } + + bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2(c, nBucketCount); } + + bucket_index_t bucket_index(const Key&, hash_code_t c, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2(c, nBucketCount); } + + bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2((hash_code_t)m_h1(mExtractKey(pNode->mValue)), nBucketCount); } + + bool compare(const Key& key, hash_code_t, node_type* pNode) const + { return mEqual(key, mExtractKey(pNode->mValue)); } + + void copy_code(node_type*, const node_type*) const + { } // Nothing to do. + + void set_code(node_type*, hash_code_t) const + { } // Nothing to do. + + void base_swap(hash_code_base& x) + { + eastl::swap(mExtractKey, x.mExtractKey); + eastl::swap(mEqual, x.mEqual); + eastl::swap(m_h1, x.m_h1); + eastl::swap(m_h2, x.m_h2); + } + + }; // hash_code_base + + + + /// hash_code_base + /// + /// Specialization: hash function and range-hashing function, + /// caching hash codes. H is provided but ignored. + /// Provides typedef and accessor required by TR1. + /// + template + struct hash_code_base + { + protected: + ExtractKey mExtractKey; + Equal mEqual; + H1 m_h1; + H2 m_h2; + + public: + typedef H1 hasher; + + H1 hash_function() const + { return m_h1; } + + Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard + { return mEqual; } // has specified in its hashtable (unordered_*) proposal. + + const Equal& key_eq() const + { return mEqual; } + + Equal& key_eq() + { return mEqual; } + + protected: + typedef uint32_t hash_code_t; + typedef uint32_t bucket_index_t; + typedef hash_node node_type; + + hash_code_base(const ExtractKey& ex, const Equal& eq, const H1& h1, const H2& h2, const default_ranged_hash&) + : mExtractKey(ex), mEqual(eq), m_h1(h1), m_h2(h2) { } + + hash_code_t get_hash_code(const Key& key) const + { return (hash_code_t)m_h1(key); } + + bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2(c, nBucketCount); } + + bucket_index_t bucket_index(const Key&, hash_code_t c, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2(c, nBucketCount); } + + bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCount) const + { return (bucket_index_t)m_h2((uint32_t)pNode->mnHashCode, nBucketCount); } + + bool compare(const Key& key, hash_code_t c, node_type* pNode) const + { return (pNode->mnHashCode == c) && mEqual(key, mExtractKey(pNode->mValue)); } + + void copy_code(node_type* pDest, const node_type* pSource) const + { pDest->mnHashCode = pSource->mnHashCode; } + + void set_code(node_type* pDest, hash_code_t c) const + { pDest->mnHashCode = c; } + + void base_swap(hash_code_base& x) + { + eastl::swap(mExtractKey, x.mExtractKey); + eastl::swap(mEqual, x.mEqual); + eastl::swap(m_h1, x.m_h1); + eastl::swap(m_h2, x.m_h2); + } + + }; // hash_code_base + + + + + + /////////////////////////////////////////////////////////////////////////// + /// hashtable + /// + /// Key and Value: arbitrary CopyConstructible types. + /// + /// ExtractKey: function object that takes a object of type Value + /// and returns a value of type Key. + /// + /// Equal: function object that takes two objects of type k and returns + /// a bool-like value that is true if the two objects are considered equal. + /// + /// H1: a hash function. A unary function object with argument type + /// Key and result type size_t. Return values should be distributed + /// over the entire range [0, numeric_limits::max()]. + /// + /// H2: a range-hashing function (in the terminology of Tavori and + /// Dreizin). This is a function which takes the output of H1 and + /// converts it to the range of [0, n]. Usually it merely takes the + /// output of H1 and mods it to n. + /// + /// H: a ranged hash function (Tavori and Dreizin). This is merely + /// a class that combines the functionality of H1 and H2 together, + /// possibly in some way that is somehow improved over H1 and H2 + /// It is a binary function whose argument types are Key and size_t + /// and whose result type is uint32_t. Given arguments k and n, the + /// return value is in the range [0, n). Default: h(k, n) = h2(h1(k), n). + /// If H is anything other than the default, H1 and H2 are ignored, + /// as H is thus overriding H1 and H2. + /// + /// RehashPolicy: Policy class with three members, all of which govern + /// the bucket count. nBucket(n) returns a bucket count no smaller + /// than n. GetBucketCount(n) returns a bucket count appropriate + /// for an element count of n. GetRehashRequired(nBucketCount, nElementCount, nElementAdd) + /// determines whether, if the current bucket count is nBucket and the + /// current element count is nElementCount, we need to increase the bucket + /// count. If so, returns pair(true, n), where n is the new + /// bucket count. If not, returns pair(false, ). + /// + /// Currently it is hard-wired that the number of buckets never + /// shrinks. Should we allow RehashPolicy to change that? + /// + /// bCacheHashCode: true if we store the value of the hash + /// function along with the value. This is a time-space tradeoff. + /// Storing it may improve lookup speed by reducing the number of + /// times we need to call the Equal function. + /// + /// bMutableIterators: true if hashtable::iterator is a mutable + /// iterator, false if iterator and const_iterator are both const + /// iterators. This is true for hash_map and hash_multimap, + /// false for hash_set and hash_multiset. + /// + /// bUniqueKeys: true if the return value of hashtable::count(k) + /// is always at most one, false if it may be an arbitrary number. + /// This is true for hash_set and hash_map and is false for + /// hash_multiset and hash_multimap. + /// + /////////////////////////////////////////////////////////////////////// + /// Note: + /// If you want to make a hashtable never increase its bucket usage, + /// call set_max_load_factor with a very high value such as 100000.f. + /// + /// find_as + /// In order to support the ability to have a hashtable of strings but + /// be able to do efficiently lookups via char pointers (i.e. so they + /// aren't converted to string objects), we provide the find_as + /// function. This function allows you to do a find with a key of a + /// type other than the hashtable key type. See the find_as function + /// for more documentation on this. + /// + /// find_by_hash + /// In the interest of supporting fast operations wherever possible, + /// we provide a find_by_hash function which finds a node using its + /// hash code. This is useful for cases where the node's hash is + /// already known, allowing us to avoid a redundant hash operation + /// in the normal find path. + /// + template + class hashtable + : public rehash_base >, + public hash_code_base + { + public: + typedef Key key_type; + typedef Value value_type; + typedef typename ExtractKey::result_type mapped_type; + typedef hash_code_base hash_code_base_type; + typedef typename hash_code_base_type::hash_code_t hash_code_t; + typedef Allocator allocator_type; + typedef Equal key_equal; + typedef ptrdiff_t difference_type; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef value_type& reference; + typedef const value_type& const_reference; + typedef node_iterator local_iterator; + typedef node_iterator const_local_iterator; + typedef hashtable_iterator iterator; + typedef hashtable_iterator const_iterator; + typedef eastl::reverse_iterator reverse_iterator; + typedef eastl::reverse_iterator const_reverse_iterator; + typedef hash_node node_type; + typedef typename type_select, iterator>::type insert_return_type; + typedef hashtable this_type; + typedef RehashPolicy rehash_policy_type; + typedef ExtractKey extract_key_type; + typedef H1 h1_type; + typedef H2 h2_type; + typedef H h_type; + + using hash_code_base_type::key_eq; + using hash_code_base_type::hash_function; + using hash_code_base_type::mExtractKey; + using hash_code_base_type::get_hash_code; + using hash_code_base_type::bucket_index; + using hash_code_base_type::compare; + using hash_code_base_type::set_code; + + static const bool kCacheHashCode = bCacheHashCode; + + enum + { + kKeyAlignment = EASTL_ALIGN_OF(key_type), + kKeyAlignmentOffset = 0, // To do: Make sure this really is zero for all uses of this template. + kValueAlignment = EASTL_ALIGN_OF(value_type), + kValueAlignmentOffset = 0, // To fix: This offset is zero for sets and >0 for maps. Need to fix this. + kAllocFlagBuckets = 0x00400000 // Flag to allocator which indicates that we are allocating buckets and not nodes. + }; + + protected: + node_type** mpBucketArray; + size_type mnBucketCount; + size_type mnElementCount; + RehashPolicy mRehashPolicy; // To do: Use base class optimization to make this go away. + allocator_type mAllocator; // To do: Use base class optimization to make this go away. + + public: + hashtable(size_type nBucketCount, const H1&, const H2&, const H&, const Equal&, const ExtractKey&, + const allocator_type& allocator = EASTL_HASHTABLE_DEFAULT_ALLOCATOR); + + template + hashtable(FowardIterator first, FowardIterator last, size_type nBucketCount, + const H1&, const H2&, const H&, const Equal&, const ExtractKey&, + const allocator_type& allocator = EASTL_HASHTABLE_DEFAULT_ALLOCATOR); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg. + + hashtable(const hashtable& x); + ~hashtable(); + + allocator_type& get_allocator(); + void set_allocator(const allocator_type& allocator); + + this_type& operator=(const this_type& x); + + void swap(this_type& x); + + public: + iterator begin() + { + iterator i(mpBucketArray); + if(!i.mpNode) + i.increment_bucket(); + return i; + } + + const_iterator begin() const + { + const_iterator i(mpBucketArray); + if(!i.mpNode) + i.increment_bucket(); + return i; + } + + iterator end() + { return iterator(mpBucketArray + mnBucketCount); } + + const_iterator end() const + { return const_iterator(mpBucketArray + mnBucketCount); } + + local_iterator begin(size_type n) + { return local_iterator(mpBucketArray[n]); } + + local_iterator end(size_type) + { return local_iterator(NULL); } + + const_local_iterator begin(size_type n) const + { return const_local_iterator(mpBucketArray[n]); } + + const_local_iterator end(size_type) const + { return const_local_iterator(NULL); } + + bool empty() const + { return mnElementCount == 0; } + + size_type size() const + { return mnElementCount; } + + size_type bucket_count() const + { return mnBucketCount; } + + size_type bucket_size(size_type n) const + { return (size_type)eastl::distance(begin(n), end(n)); } + + //size_type bucket(const key_type& k) const + // { return bucket_index(k, (hash code here), (uint32_t)mnBucketCount); } + + public: + float load_factor() const + { return (float)mnElementCount / (float)mnBucketCount; } + + // Inherited from the base class. + // Returns the max load factor, which is the load factor beyond + // which we rebuild the container with a new bucket count. + // get_max_load_factor comes from rehash_base. + // float get_max_load_factor() const; + + // Inherited from the base class. + // If you want to make the hashtable never rehash (resize), + // set the max load factor to be a very high number (e.g. 100000.f). + // set_max_load_factor comes from rehash_base. + // void set_max_load_factor(float fMaxLoadFactor); + + /// Generalization of get_max_load_factor. This is an extension that's + /// not present in TR1. + const rehash_policy_type& rehash_policy() const + { return mRehashPolicy; } + + /// Generalization of set_max_load_factor. This is an extension that's + /// not present in TR1. + void rehash_policy(const rehash_policy_type& rehashPolicy); + + public: + + insert_return_type insert(const value_type& value); + iterator insert(const_iterator, const value_type& value); + + template + void insert(InputIterator first, InputIterator last); + + public: + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + size_type erase(const key_type& k); + + void clear(); + void clear(bool clearBuckets); + void reset(); + void rehash(size_type nBucketCount); + + public: + iterator find(const key_type& key); + const_iterator find(const key_type& key) const; + + /// Implements a find whereby the user supplies a comparison of a different type + /// than the hashtable value_type. A useful case of this is one whereby you have + /// a container of string objects but want to do searches via passing in char pointers. + /// The problem is that without this kind of find, you need to do the expensive operation + /// of converting the char pointer to a string so it can be used as the argument to the + /// find function. + /// + /// Example usage (namespaces omitted for brevity): + /// hash_set hashSet; + /// hashSet.find_as("hello"); // Use default hash and compare. + /// + /// Example usage (note that the predicate uses string as first type and char* as second): + /// hash_set hashSet; + /// hashSet.find_as("hello", hash(), equal_to_2()); + /// + template + iterator find_as(const U& u, UHash uhash, BinaryPredicate predicate); + + template + const_iterator find_as(const U& u, UHash uhash, BinaryPredicate predicate) const; + + template + iterator find_as(const U& u); + + template + const_iterator find_as(const U& u) const; + + /// Implements a find whereby the user supplies the node's hash code. + /// + iterator find_by_hash(hash_code_t c); + const_iterator find_by_hash(hash_code_t c) const; + + size_type count(const key_type& k) const; + + eastl::pair equal_range(const key_type& k); + eastl::pair equal_range(const key_type& k) const; + + public: + bool validate() const; + int validate_iterator(const_iterator i) const; + + protected: + node_type* DoAllocateNode(const value_type& value); + node_type* DoAllocateNodeFromKey(const key_type& key); + void DoFreeNode(node_type* pNode); + void DoFreeNodes(node_type** pBucketArray, size_type); + + node_type** DoAllocateBuckets(size_type n); + void DoFreeBuckets(node_type** pBucketArray, size_type n); + + eastl::pair DoInsertValue(const value_type& value, true_type); + iterator DoInsertValue(const value_type& value, false_type); + + eastl::pair DoInsertKey(const key_type& key, true_type); + iterator DoInsertKey(const key_type& key, false_type); + + void DoRehash(size_type nBucketCount); + node_type* DoFindNode(node_type* pNode, const key_type& k, hash_code_t c) const; + + template + node_type* DoFindNode(node_type* pNode, const U& u, BinaryPredicate predicate) const; + + node_type* DoFindNode(node_type* pNode, hash_code_t c) const; + + }; // class hashtable + + + + + + /////////////////////////////////////////////////////////////////////// + // node_iterator_base + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const node_iterator_base& a, const node_iterator_base& b) + { return a.mpNode == b.mpNode; } + + template + inline bool operator!=(const node_iterator_base& a, const node_iterator_base& b) + { return a.mpNode != b.mpNode; } + + + + + /////////////////////////////////////////////////////////////////////// + // hashtable_iterator_base + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const hashtable_iterator_base& a, const hashtable_iterator_base& b) + { return a.mpNode == b.mpNode; } + + template + inline bool operator!=(const hashtable_iterator_base& a, const hashtable_iterator_base& b) + { return a.mpNode != b.mpNode; } + + + + + /////////////////////////////////////////////////////////////////////// + // hashtable + /////////////////////////////////////////////////////////////////////// + + template + hashtable + ::hashtable(size_type nBucketCount, const H1& h1, const H2& h2, const H& h, + const Eq& eq, const EK& ek, const allocator_type& allocator) + : rehash_base(), + hash_code_base(ek, eq, h1, h2, h), + mnBucketCount(0), + mnElementCount(0), + mRehashPolicy(), + mAllocator(allocator) + { + if(nBucketCount < 2) // If we are starting in an initially empty state, with no memory allocation done. + reset(); + else // Else we are creating a potentially non-empty hashtable... + { + EASTL_ASSERT(nBucketCount < 10000000); + mnBucketCount = (size_type)mRehashPolicy.GetNextBucketCount((uint32_t)nBucketCount); + mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will always be at least 2. + } + } + + + + template + template + hashtable::hashtable(FowardIterator first, FowardIterator last, size_type nBucketCount, + const H1& h1, const H2& h2, const H& h, + const Eq& eq, const EK& ek, const allocator_type& allocator) + : rehash_base(), + hash_code_base(ek, eq, h1, h2, h), + //mnBucketCount(0), // This gets re-assigned below. + mnElementCount(0), + mRehashPolicy(), + mAllocator(allocator) + { + if(nBucketCount < 2) + { + const size_type nElementCount = (size_type)eastl::ht_distance(first, last); + mnBucketCount = (size_type)mRehashPolicy.GetBucketCount((uint32_t)nElementCount); + } + else + { + EASTL_ASSERT(nBucketCount < 10000000); + mnBucketCount = nBucketCount; + } + + mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will always be at least 2. + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + for(; first != last; ++first) + insert(*first); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + clear(); + DoFreeBuckets(mpBucketArray, mnBucketCount); + throw; + } + #endif + } + + + + template + hashtable::hashtable(const this_type& x) + : rehash_base(x), + hash_code_base(x), + mnBucketCount(x.mnBucketCount), + mnElementCount(x.mnElementCount), + mRehashPolicy(x.mRehashPolicy), + mAllocator(x.mAllocator) + { + if(mnElementCount) // If there is anything to copy... + { + mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will be at least 2. + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + for(size_type i = 0; i < x.mnBucketCount; ++i) + { + node_type* pNodeSource = x.mpBucketArray[i]; + node_type** ppNodeDest = mpBucketArray + i; + + while(pNodeSource) + { + *ppNodeDest = DoAllocateNode(pNodeSource->mValue); + this->copy_code(*ppNodeDest, pNodeSource); + ppNodeDest = &(*ppNodeDest)->mpNext; + pNodeSource = pNodeSource->mpNext; + } + } + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + clear(); + DoFreeBuckets(mpBucketArray, mnBucketCount); + throw; + } + #endif + } + else + { + // In this case, instead of allocate memory and copy nothing from x, + // we reset ourselves to a zero allocation state. + reset(); + } + } + + + + template + inline typename hashtable::allocator_type& + hashtable::get_allocator() + { + return mAllocator; + } + + + + template + inline void hashtable::set_allocator(const allocator_type& allocator) + { + mAllocator = allocator; + } + + + + template + inline typename hashtable::this_type& + hashtable::operator=(const this_type& x) + { + if(this != &x) + { + clear(); + + #if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; + #endif + + insert(x.begin(), x.end()); + } + return *this; + } + + + + template + inline hashtable::~hashtable() + { + clear(); + DoFreeBuckets(mpBucketArray, mnBucketCount); + } + + + + template + typename hashtable::node_type* + hashtable::DoAllocateNode(const value_type& value) + { + node_type* const pNode = (node_type*)allocate_memory(mAllocator, sizeof(node_type), kValueAlignment, kValueAlignmentOffset); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + ::new(&pNode->mValue) value_type(value); + pNode->mpNext = NULL; + return pNode; + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + EASTLFree(mAllocator, pNode, sizeof(node_type)); + throw; + } + #endif + } + + + + template + typename hashtable::node_type* + hashtable::DoAllocateNodeFromKey(const key_type& key) + { + node_type* const pNode = (node_type*)allocate_memory(mAllocator, sizeof(node_type), kValueAlignment, kValueAlignmentOffset); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + ::new(&pNode->mValue) value_type(key); + pNode->mpNext = NULL; + return pNode; + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + EASTLFree(mAllocator, pNode, sizeof(node_type)); + throw; + } + #endif + } + + + + template + inline void hashtable::DoFreeNode(node_type* pNode) + { + pNode->~node_type(); + EASTLFree(mAllocator, pNode, sizeof(node_type)); + } + + + + template + void hashtable::DoFreeNodes(node_type** pNodeArray, size_type n) + { + for(size_type i = 0; i < n; ++i) + { + node_type* pNode = pNodeArray[i]; + while(pNode) + { + node_type* const pTempNode = pNode; + pNode = pNode->mpNext; + DoFreeNode(pTempNode); + } + pNodeArray[i] = NULL; + } + } + + + + template + typename hashtable::node_type** + hashtable::DoAllocateBuckets(size_type n) + { + // We allocate one extra bucket to hold a sentinel, an arbitrary + // non-null pointer. Iterator increment relies on this. + EASTL_ASSERT(n > 1); // We reserve an mnBucketCount of 1 for the shared gpEmptyBucketArray. + EASTL_CT_ASSERT(kAllocFlagBuckets == 0x00400000); // Currently we expect this to be so, because the allocator has a copy of this enum. + node_type** const pBucketArray = (node_type**)EASTLAllocFlags(mAllocator, (n + 1) * sizeof(node_type*), kAllocFlagBuckets); + //eastl::fill(pBucketArray, pBucketArray + n, (node_type*)NULL); + memset(pBucketArray, 0, n * sizeof(node_type*)); + pBucketArray[n] = reinterpret_cast((uintptr_t)~0); + return pBucketArray; + } + + + + template + inline void hashtable::DoFreeBuckets(node_type** pBucketArray, size_type n) + { + // If n <= 1, then pBucketArray is from the shared gpEmptyBucketArray. We don't test + // for pBucketArray == &gpEmptyBucketArray because one library have a different gpEmptyBucketArray + // than another but pass a hashtable to another. So we go by the size. + if(n > 1) + EASTLFree(mAllocator, pBucketArray, (n + 1) * sizeof(node_type*)); // '+1' because DoAllocateBuckets allocates nBucketCount + 1 buckets in order to have a NULL sentinel at the end. + } + + + + template + void hashtable::swap(this_type& x) + { + if(mAllocator == x.mAllocator) // If allocators are equivalent... + { + // We leave mAllocator as-is. + hash_code_base::base_swap(x); // hash_code_base has multiple implementations, so we let them handle the swap. + eastl::swap(mRehashPolicy, x.mRehashPolicy); + eastl::swap(mpBucketArray, x.mpBucketArray); + eastl::swap(mnBucketCount, x.mnBucketCount); + eastl::swap(mnElementCount, x.mnElementCount); + } + else + { + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + } + } + + + template + inline void hashtable::rehash_policy(const rehash_policy_type& rehashPolicy) + { + mRehashPolicy = rehashPolicy; + + const size_type nBuckets = rehashPolicy.GetBucketCount((uint32_t)mnElementCount); + + if(nBuckets > mnBucketCount) + DoRehash(nBuckets); + } + + + + template + inline typename hashtable::iterator + hashtable::find(const key_type& k) + { + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + + node_type* const pNode = DoFindNode(mpBucketArray[n], k, c); + return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + + template + inline typename hashtable::const_iterator + hashtable::find(const key_type& k) const + { + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + + node_type* const pNode = DoFindNode(mpBucketArray[n], k, c); + return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + + template + template + inline typename hashtable::iterator + hashtable::find_as(const U& other, UHash uhash, BinaryPredicate predicate) + { + const hash_code_t c = (hash_code_t)uhash(other); + const size_type n = (size_type)(c % mnBucketCount); // This assumes we are using the mod range policy. + + node_type* const pNode = DoFindNode(mpBucketArray[n], other, predicate); + return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + + template + template + inline typename hashtable::const_iterator + hashtable::find_as(const U& other, UHash uhash, BinaryPredicate predicate) const + { + const hash_code_t c = (hash_code_t)uhash(other); + const size_type n = (size_type)(c % mnBucketCount); // This assumes we are using the mod range policy. + + node_type* const pNode = DoFindNode(mpBucketArray[n], other, predicate); + return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + /// hashtable_find + /// + /// Helper function that defaults to using hash and equal_to_2. + /// This makes it so that by default you don't need to provide these. + /// Note that the default hash functions may not be what you want, though. + /// + /// Example usage. Instead of this: + /// hash_set hashSet; + /// hashSet.find("hello", hash(), equal_to_2()); + /// + /// You can use this: + /// hash_set hashSet; + /// hashtable_find(hashSet, "hello"); + /// + template + inline typename H::iterator hashtable_find(H& hashTable, U u) + { return hashTable.find_as(u, eastl::hash(), eastl::equal_to_2()); } + + template + inline typename H::const_iterator hashtable_find(const H& hashTable, U u) + { return hashTable.find_as(u, eastl::hash(), eastl::equal_to_2()); } + + + + template + template + inline typename hashtable::iterator + hashtable::find_as(const U& other) + { return eastl::hashtable_find(*this, other); } + // VC++ doesn't appear to like the following, though it seems correct to me. + // So we implement the workaround above until we can straighten this out. + //{ return find_as(other, eastl::hash(), eastl::equal_to_2()); } + + + template + template + inline typename hashtable::const_iterator + hashtable::find_as(const U& other) const + { return eastl::hashtable_find(*this, other); } + // VC++ doesn't appear to like the following, though it seems correct to me. + // So we implement the workaround above until we can straighten this out. + //{ return find_as(other, eastl::hash(), eastl::equal_to_2()); } + + + template + inline typename hashtable::iterator + hashtable::find_by_hash(hash_code_t c) + { + const size_type n = (size_type)bucket_index(c, (uint32_t)mnBucketCount); + + node_type* const pNode = DoFindNode(mpBucketArray[n], c); + return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + template + inline typename hashtable::const_iterator + hashtable::find_by_hash(hash_code_t c) const + { + const size_type n = (size_type)bucket_index(c, (uint32_t)mnBucketCount); + + node_type* const pNode = DoFindNode(mpBucketArray[n], c); + return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end() + } + + + template + typename hashtable::size_type + hashtable::count(const key_type& k) const + { + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + size_type result = 0; + + // To do: Make a specialization for bU (unique keys) == true and take + // advantage of the fact that the count will always be zero or one in that case. + for(node_type* pNode = mpBucketArray[n]; pNode; pNode = pNode->mpNext) + { + if(compare(k, c, pNode)) + ++result; + } + return result; + } + + + + template + eastl::pair::iterator, + typename hashtable::iterator> + hashtable::equal_range(const key_type& k) + { + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + + node_type** head = mpBucketArray + n; + node_type* pNode = DoFindNode(*head, k, c); + + if(pNode) + { + node_type* p1 = pNode->mpNext; + + for(; p1; p1 = p1->mpNext) + { + if(!compare(k, c, p1)) + break; + } + + iterator first(pNode, head); + iterator last(p1, head); + + if(!p1) + last.increment_bucket(); + + return eastl::pair(first, last); + } + + return eastl::pair(iterator(mpBucketArray + mnBucketCount), // iterator(mpBucketArray + mnBucketCount) == end() + iterator(mpBucketArray + mnBucketCount)); + } + + + + + template + eastl::pair::const_iterator, + typename hashtable::const_iterator> + hashtable::equal_range(const key_type& k) const + { + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + node_type** head = mpBucketArray + n; + node_type* pNode = DoFindNode(*head, k, c); + + if(pNode) + { + node_type* p1 = pNode->mpNext; + + for(; p1; p1 = p1->mpNext) + { + if(!compare(k, c, p1)) + break; + } + + const_iterator first(pNode, head); + const_iterator last(p1, head); + + if(!p1) + last.increment_bucket(); + + return eastl::pair(first, last); + } + + return eastl::pair(const_iterator(mpBucketArray + mnBucketCount), // iterator(mpBucketArray + mnBucketCount) == end() + const_iterator(mpBucketArray + mnBucketCount)); + } + + + + template + inline typename hashtable::node_type* + hashtable::DoFindNode(node_type* pNode, const key_type& k, hash_code_t c) const + { + for(; pNode; pNode = pNode->mpNext) + { + if(compare(k, c, pNode)) + return pNode; + } + return NULL; + } + + + + template + template + inline typename hashtable::node_type* + hashtable::DoFindNode(node_type* pNode, const U& other, BinaryPredicate predicate) const + { + for(; pNode; pNode = pNode->mpNext) + { + if(predicate(mExtractKey(pNode->mValue), other)) // Intentionally compare with key as first arg and other as second arg. + return pNode; + } + return NULL; + } + + + + template + inline typename hashtable::node_type* + hashtable::DoFindNode(node_type* pNode, hash_code_t c) const + { + for(; pNode; pNode = pNode->mpNext) + { + if(pNode->mnHashCode == c) + return pNode; + } + return NULL; + } + + + + template + eastl::pair::iterator, bool> + hashtable::DoInsertValue(const value_type& value, true_type) // true_type means bUniqueKeys is true. + { + const key_type& k = mExtractKey(value); + const hash_code_t c = get_hash_code(k); + size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + node_type* const pNode = DoFindNode(mpBucketArray[n], k, c); + + if(pNode == NULL) + { + const eastl::pair bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1); + + // Allocate the new node before doing the rehash so that we don't + // do a rehash if the allocation throws. + node_type* const pNodeNew = DoAllocateNode(value); + set_code(pNodeNew, c); // This is a no-op for most hashtables. + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + if(bRehash.first) + { + n = (size_type)bucket_index(k, c, (uint32_t)bRehash.second); + DoRehash(bRehash.second); + } + + EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]); + pNodeNew->mpNext = mpBucketArray[n]; + mpBucketArray[n] = pNodeNew; + ++mnElementCount; + + return eastl::pair(iterator(pNodeNew, mpBucketArray + n), true); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + DoFreeNode(pNodeNew); + throw; + } + #endif + } + + return eastl::pair(iterator(pNode, mpBucketArray + n), false); + } + + + + template + typename hashtable::iterator + hashtable::DoInsertValue(const value_type& value, false_type) // false_type means bUniqueKeys is false. + { + const eastl::pair bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1); + + if(bRehash.first) + DoRehash(bRehash.second); + + const key_type& k = mExtractKey(value); + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + + node_type* const pNodeNew = DoAllocateNode(value); + set_code(pNodeNew, c); // This is a no-op for most hashtables. + + // To consider: Possibly make this insertion not make equal elements contiguous. + // As it stands now, we insert equal values contiguously in the hashtable. + // The benefit is that equal_range can work in a sensible manner and that + // erase(value) can more quickly find equal values. The downside is that + // this insertion operation taking some extra time. How important is it to + // us that equal_range span all equal items? + node_type* const pNodePrev = DoFindNode(mpBucketArray[n], k, c); + + if(pNodePrev == NULL) + { + EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]); + pNodeNew->mpNext = mpBucketArray[n]; + mpBucketArray[n] = pNodeNew; + } + else + { + pNodeNew->mpNext = pNodePrev->mpNext; + pNodePrev->mpNext = pNodeNew; + } + + ++mnElementCount; + + return iterator(pNodeNew, mpBucketArray + n); + } + + + + template + eastl::pair::iterator, bool> + hashtable::DoInsertKey(const key_type& key, true_type) // true_type means bUniqueKeys is true. + { + const hash_code_t c = get_hash_code(key); + size_type n = (size_type)bucket_index(key, c, (uint32_t)mnBucketCount); + node_type* const pNode = DoFindNode(mpBucketArray[n], key, c); + + if(pNode == NULL) + { + const eastl::pair bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1); + + // Allocate the new node before doing the rehash so that we don't + // do a rehash if the allocation throws. + node_type* const pNodeNew = DoAllocateNodeFromKey(key); + set_code(pNodeNew, c); // This is a no-op for most hashtables. + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + if(bRehash.first) + { + n = (size_type)bucket_index(key, c, (uint32_t)bRehash.second); + DoRehash(bRehash.second); + } + + EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]); + pNodeNew->mpNext = mpBucketArray[n]; + mpBucketArray[n] = pNodeNew; + ++mnElementCount; + + return eastl::pair(iterator(pNodeNew, mpBucketArray + n), true); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + DoFreeNode(pNodeNew); + throw; + } + #endif + } + + return eastl::pair(iterator(pNode, mpBucketArray + n), false); + } + + + + template + typename hashtable::iterator + hashtable::DoInsertKey(const key_type& key, false_type) // false_type means bUniqueKeys is false. + { + const eastl::pair bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1); + + if(bRehash.first) + DoRehash(bRehash.second); + + const hash_code_t c = get_hash_code(key); + const size_type n = (size_type)bucket_index(key, c, (uint32_t)mnBucketCount); + + node_type* const pNodeNew = DoAllocateNodeFromKey(key); + set_code(pNodeNew, c); // This is a no-op for most hashtables. + + // To consider: Possibly make this insertion not make equal elements contiguous. + // As it stands now, we insert equal values contiguously in the hashtable. + // The benefit is that equal_range can work in a sensible manner and that + // erase(value) can more quickly find equal values. The downside is that + // this insertion operation taking some extra time. How important is it to + // us that equal_range span all equal items? + node_type* const pNodePrev = DoFindNode(mpBucketArray[n], key, c); + + if(pNodePrev == NULL) + { + EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]); + pNodeNew->mpNext = mpBucketArray[n]; + mpBucketArray[n] = pNodeNew; + } + else + { + pNodeNew->mpNext = pNodePrev->mpNext; + pNodePrev->mpNext = pNodeNew; + } + + ++mnElementCount; + + return iterator(pNodeNew, mpBucketArray + n); + } + + + + template + typename hashtable::insert_return_type + hashtable::insert(const value_type& value) + { + return DoInsertValue(value, integral_constant()); + } + + + + template + typename hashtable::iterator + hashtable::insert(const_iterator, const value_type& value) + { + // We ignore the first argument (hint iterator). It's not likely to be useful for hashtable containers. + + #ifdef __MWERKS__ // The Metrowerks compiler has a bug. + insert_return_type result = insert(value); + return result.first; // Note by Paul Pedriana while perusing this code: This code will fail to compile when bU is false (i.e. for multiset, multimap). + + #elif defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around) + EASTL_ASSERT(empty()); // This function cannot return the correct return value on GCC 2.x. Unless, that is, the container is empty. + DoInsertValue(value, integral_constant()); + return begin(); // This is the wrong answer. + #else + insert_return_type result = DoInsertValue(value, integral_constant()); + return result.first; // Note by Paul Pedriana while perusing this code: This code will fail to compile when bU is false (i.e. for multiset, multimap). + #endif + } + + + + template + template + void + hashtable::insert(InputIterator first, InputIterator last) + { + const uint32_t nElementAdd = (uint32_t)eastl::ht_distance(first, last); + const eastl::pair bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, nElementAdd); + + if(bRehash.first) + DoRehash(bRehash.second); + + for(; first != last; ++first) + { + #ifdef __MWERKS__ // The Metrowerks compiler has a bug. + insert(*first); + #else + DoInsertValue(*first, integral_constant()); + #endif + } + } + + + + template + typename hashtable::iterator + hashtable::erase(iterator i) + { + iterator iNext(i); + ++iNext; + + node_type* pNode = i.mpNode; + node_type* pNodeCurrent = *i.mpBucket; + + if(pNodeCurrent == pNode) + *i.mpBucket = pNodeCurrent->mpNext; + else + { + // We have a singly-linked list, so we have no choice but to + // walk down it till we find the node before the node at 'i'. + node_type* pNodeNext = pNodeCurrent->mpNext; + + while(pNodeNext != pNode) + { + pNodeCurrent = pNodeNext; + pNodeNext = pNodeCurrent->mpNext; + } + + pNodeCurrent->mpNext = pNodeNext->mpNext; + } + + DoFreeNode(pNode); + --mnElementCount; + + return iNext; + } + + + + template + inline typename hashtable::iterator + hashtable::erase(iterator first, iterator last) + { + while(first != last) + first = erase(first); + return first; + } + + + + template + typename hashtable::reverse_iterator + hashtable::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + + template + inline typename hashtable::reverse_iterator + hashtable::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + + template + typename hashtable::size_type + hashtable::erase(const key_type& k) + { + // To do: Reimplement this function to do a single loop and not try to be + // smart about element contiguity. The mechanism here is only a benefit if the + // buckets are heavily overloaded; otherwise this mechanism may be slightly slower. + + const hash_code_t c = get_hash_code(k); + const size_type n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount); + const size_type nElementCountSaved = mnElementCount; + + node_type** pBucketArray = mpBucketArray + n; + + while(*pBucketArray && !compare(k, c, *pBucketArray)) + pBucketArray = &(*pBucketArray)->mpNext; + + while(*pBucketArray && compare(k, c, *pBucketArray)) + { + node_type* const pNode = *pBucketArray; + *pBucketArray = pNode->mpNext; + DoFreeNode(pNode); + --mnElementCount; + } + + return nElementCountSaved - mnElementCount; + } + + + + template + inline void hashtable::clear() + { + DoFreeNodes(mpBucketArray, mnBucketCount); + mnElementCount = 0; + } + + + + template + inline void hashtable::clear(bool clearBuckets) + { + DoFreeNodes(mpBucketArray, mnBucketCount); + if(clearBuckets) + { + DoFreeBuckets(mpBucketArray, mnBucketCount); + reset(); + } + mnElementCount = 0; + } + + + + template + inline void hashtable::reset() + { + // The reset function is a special extension function which unilaterally + // resets the container to an empty state without freeing the memory of + // the contained objects. This is useful for very quickly tearing down a + // container built into scratch memory. + mnBucketCount = 1; + + #ifdef _MSC_VER + mpBucketArray = (node_type**)&gpEmptyBucketArray[0]; + #else + void* p = &gpEmptyBucketArray[0]; + memcpy(&mpBucketArray, &p, sizeof(mpBucketArray)); // Other compilers implement strict aliasing and casting is thus unsafe. + #endif + + mnElementCount = 0; + mRehashPolicy.mnNextResize = 0; + } + + + + template + inline void hashtable::rehash(size_type nBucketCount) + { + // Note that we unilaterally use the passed in bucket count; we do not attempt migrate it + // up to the next prime number. We leave it at the user's discretion to do such a thing. + DoRehash(nBucketCount); + } + + + + template + void hashtable::DoRehash(size_type nNewBucketCount) + { + node_type** const pBucketArray = DoAllocateBuckets(nNewBucketCount); // nNewBucketCount should always be >= 2. + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + node_type* pNode; + + for(size_type i = 0; i < mnBucketCount; ++i) + { + while((pNode = mpBucketArray[i]) != NULL) // Using '!=' disables compiler warnings. + { + const size_type nNewBucketIndex = (size_type)bucket_index(pNode, (uint32_t)nNewBucketCount); + + mpBucketArray[i] = pNode->mpNext; + pNode->mpNext = pBucketArray[nNewBucketIndex]; + pBucketArray[nNewBucketIndex] = pNode; + } + } + + DoFreeBuckets(mpBucketArray, mnBucketCount); + mnBucketCount = nNewBucketCount; + mpBucketArray = pBucketArray; + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + // A failure here means that a hash function threw an exception. + // We can't restore the previous state without calling the hash + // function again, so the only sensible recovery is to delete everything. + DoFreeNodes(pBucketArray, nNewBucketCount); + DoFreeBuckets(pBucketArray, nNewBucketCount); + DoFreeNodes(mpBucketArray, mnBucketCount); + mnElementCount = 0; + throw; + } + #endif + } + + + template + inline bool hashtable::validate() const + { + // Verify our empty bucket array is unmodified. + if(gpEmptyBucketArray[0] != NULL) + return false; + + if(gpEmptyBucketArray[1] != (void*)uintptr_t(~0)) + return false; + + // Verify that we have at least one bucket. Calculations can + // trigger division by zero exceptions otherwise. + if(mnBucketCount == 0) + return false; + + // Verify that gpEmptyBucketArray is used correctly. + // gpEmptyBucketArray is only used when initially empty. + if((void**)mpBucketArray == &gpEmptyBucketArray[0]) + { + if(mnElementCount) // gpEmptyBucketArray is used only for empty hash tables. + return false; + + if(mnBucketCount != 1) // gpEmptyBucketArray is used exactly an only for mnBucketCount == 1. + return false; + } + else + { + if(mnBucketCount < 2) // Small bucket counts *must* use gpEmptyBucketArray. + return false; + } + + // Verify that the element count matches mnElementCount. + size_type nElementCount = 0; + + for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp) + ++nElementCount; + + if(nElementCount != mnElementCount) + return false; + + // To do: Verify that individual elements are in the expected buckets. + + return true; + } + + + template + int hashtable::validate_iterator(const_iterator i) const + { + // To do: Come up with a more efficient mechanism of doing this. + + for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp) + { + if(temp == i) + return (isf_valid | isf_current | isf_can_dereference); + } + + if(i == end()) + return (isf_valid | isf_current); + + return isf_none; + } + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const hashtable& a, + const hashtable& b) + { + return (a.size() == b.size()) && eastl::equal(a.begin(), a.end(), b.begin()); + } + + + // Comparing hash tables for less-ness is an odd thing to do. We provide it for + // completeness, though the user is advised to be wary of how they use this. + template + inline bool operator<(const hashtable& a, + const hashtable& b) + { + // This requires hash table elements to support operator<. Since the hash table + // doesn't compare elements via less (it does so via equals), we must use the + // globally defined operator less for the elements. + return eastl::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); + } + + + template + inline bool operator!=(const hashtable& a, + const hashtable& b) + { + return !(a == b); + } + + + template + inline bool operator>(const hashtable& a, + const hashtable& b) + { + return b < a; + } + + + template + inline bool operator<=(const hashtable& a, + const hashtable& b) + { + return !(b < a); + } + + + template + inline bool operator>=(const hashtable& a, + const hashtable& b) + { + return !(a < b); + } + + + template + inline void swap(const hashtable& a, + const hashtable& b) + { + a.swap(b); + } + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/red_black_tree.h b/lib/eastl/include/EASTL/internal/red_black_tree.h new file mode 100644 index 0000000..ae09bd6 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/red_black_tree.h @@ -0,0 +1,1917 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/red_black_tree.h +// Written by Paul Pedriana 2005. +////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_RED_BLACK_TREE_H +#define EASTL_RED_BLACK_TREE_H + + + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) + #include + #include + #pragma warning(pop) +#else + #include + #include +#endif + + +#ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable: 4512) // 'class' : assignment operator could not be generated + #pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc +#endif + + +namespace eastl +{ + + /// EASTL_RBTREE_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_RBTREE_DEFAULT_NAME + #define EASTL_RBTREE_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " rbtree" // Unless the user overrides something, this is "EASTL rbtree". + #endif + + + /// EASTL_RBTREE_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_RBTREE_DEFAULT_ALLOCATOR + #define EASTL_RBTREE_DEFAULT_ALLOCATOR allocator_type(EASTL_RBTREE_DEFAULT_NAME) + #endif + + + + /// RBTreeColor + /// + enum RBTreeColor + { + kRBTreeColorRed, + kRBTreeColorBlack + }; + + + + /// RBTreeColor + /// + enum RBTreeSide + { + kRBTreeSideLeft, + kRBTreeSideRight + }; + + + + /// rbtree_node_base + /// + /// We define a rbtree_node_base separately from rbtree_node (below), because it + /// allows us to have non-templated operations, and it makes it so that the + /// rbtree anchor node doesn't carry a T with it, which would waste space and + /// possibly lead to surprising the user due to extra Ts existing that the user + /// didn't explicitly create. The downside to all of this is that it makes debug + /// viewing of an rbtree harder, given that the node pointers are of type + /// rbtree_node_base and not rbtree_node. + /// + struct rbtree_node_base + { + typedef rbtree_node_base this_type; + + public: + this_type* mpNodeRight; // Declared first because it is used most often. + this_type* mpNodeLeft; + this_type* mpNodeParent; + char mColor; // We only need one bit here, would be nice if we could stuff that bit somewhere else. + }; + + + /// rbtree_node + /// + template + struct rbtree_node : public rbtree_node_base + { + Value mValue; // For set and multiset, this is the user's value, for map and multimap, this is a pair of key/value. + }; + + + + + // rbtree_node_base functions + // + // These are the fundamental functions that we use to maintain the + // tree. The bulk of the work of the tree maintenance is done in + // these functions. + // + EASTL_API rbtree_node_base* RBTreeIncrement (const rbtree_node_base* pNode); + EASTL_API rbtree_node_base* RBTreeDecrement (const rbtree_node_base* pNode); + EASTL_API rbtree_node_base* RBTreeGetMinChild (const rbtree_node_base* pNode); + EASTL_API rbtree_node_base* RBTreeGetMaxChild (const rbtree_node_base* pNode); + EASTL_API size_t RBTreeGetBlackCount(const rbtree_node_base* pNodeTop, + const rbtree_node_base* pNodeBottom); + EASTL_API void RBTreeInsert ( rbtree_node_base* pNode, + rbtree_node_base* pNodeParent, + rbtree_node_base* pNodeAnchor, + RBTreeSide insertionSide); + EASTL_API void RBTreeErase ( rbtree_node_base* pNode, + rbtree_node_base* pNodeAnchor); + + + + + + + + /// rbtree_iterator + /// + template + struct rbtree_iterator + { + typedef rbtree_iterator this_type; + typedef rbtree_iterator iterator; + typedef rbtree_iterator const_iterator; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef rbtree_node_base base_node_type; + typedef rbtree_node node_type; + typedef Pointer pointer; + typedef Reference reference; + typedef EASTL_ITC_NS::bidirectional_iterator_tag iterator_category; + + public: + node_type* mpNode; + + public: + rbtree_iterator(); + explicit rbtree_iterator(const node_type* pNode); + rbtree_iterator(const iterator& x); + + reference operator*() const; + pointer operator->() const; + + rbtree_iterator& operator++(); + rbtree_iterator operator++(int); + + rbtree_iterator& operator--(); + rbtree_iterator operator--(int); + + }; // rbtree_iterator + + + + + + /////////////////////////////////////////////////////////////////////////////// + // rb_base + // + // This class allows us to use a generic rbtree as the basis of map, multimap, + // set, and multiset transparently. The vital template parameters for this are + // the ExtractKey and the bUniqueKeys parameters. + // + // If the rbtree has a value type of the form pair (i.e. it is a map or + // multimap and not a set or multiset) and a key extraction policy that returns + // the first part of the pair, the rbtree gets a mapped_type typedef. + // If it satisfies those criteria and also has unique keys, then it also gets an + // operator[] (which only map and set have and multimap and multiset don't have). + // + /////////////////////////////////////////////////////////////////////////////// + + + + /// rb_base + /// This specialization is used for 'set'. In this case, Key and Value + /// will be the same as each other and ExtractKey will be eastl::use_self. + /// + template + struct rb_base + { + typedef ExtractKey extract_key; + + public: + Compare mCompare; // To do: Make sure that empty Compare classes go away via empty base optimizations. + + public: + rb_base() : mCompare() {} + rb_base(const Compare& compare) : mCompare(compare) {} + }; + + + /// rb_base + /// This class is used for 'multiset'. + /// In this case, Key and Value will be the same as each + /// other and ExtractKey will be eastl::use_self. + /// + template + struct rb_base + { + typedef ExtractKey extract_key; + + public: + Compare mCompare; // To do: Make sure that empty Compare classes go away via empty base optimizations. + + public: + rb_base() : mCompare() {} + rb_base(const Compare& compare) : mCompare(compare) {} + }; + + + /// rb_base + /// This specialization is used for 'map'. + /// + template + struct rb_base, true, RBTree> + { + typedef eastl::use_first extract_key; + + public: + Compare mCompare; // To do: Make sure that empty Compare classes go away via empty base optimizations. + + public: + rb_base() : mCompare() {} + rb_base(const Compare& compare) : mCompare(compare) {} + }; + + + /// rb_base + /// This specialization is used for 'multimap'. + /// + template + struct rb_base, false, RBTree> + { + typedef eastl::use_first extract_key; + + public: + Compare mCompare; // To do: Make sure that empty Compare classes go away via empty base optimizations. + + public: + rb_base() : mCompare() {} + rb_base(const Compare& compare) : mCompare(compare) {} + }; + + + + + + /// rbtree + /// + /// rbtree is the red-black tree basis for the map, multimap, set, and multiset + /// containers. Just about all the work of those containers is done here, and + /// they are merely a shell which sets template policies that govern the code + /// generation for this rbtree. + /// + /// This rbtree implementation is pretty much the same as all other modern + /// rbtree implementations, as the topic is well known and researched. We may + /// choose to implement a "relaxed balancing" option at some point in the + /// future if it is deemed worthwhile. Most rbtree implementations don't do this. + /// + /// The primary rbtree member variable is mAnchor, which is a node_type and + /// acts as the end node. However, like any other node, it has mpNodeLeft, + /// mpNodeRight, and mpNodeParent members. We do the conventional trick of + /// assigning begin() (left-most rbtree node) to mpNodeLeft, assigning + /// 'end() - 1' (a.k.a. rbegin()) to mpNodeRight, and assigning the tree root + /// node to mpNodeParent. + /// + /// Compare (functor): This is a comparison class which defaults to 'less'. + /// It is a common STL thing which takes two arguments and returns true if + /// the first is less than the second. + /// + /// ExtractKey (functor): This is a class which gets the key from a stored + /// node. With map and set, the node is a pair, whereas with set and multiset + /// the node is just the value. ExtractKey will be either eastl::use_first (map and multimap) + /// or eastl::use_self (set and multiset). + /// + /// bMutableIterators (bool): true if rbtree::iterator is a mutable + /// iterator, false if iterator and const_iterator are both const iterators. + /// It will be true for map and multimap and false for set and multiset. + /// + /// bUniqueKeys (bool): true if the keys are to be unique, and false if there + /// can be multiple instances of a given key. It will be true for set and map + /// and false for multiset and multimap. + /// + /// To consider: Add an option for relaxed tree balancing. This could result + /// in performance improvements but would require a more complicated implementation. + /// + /////////////////////////////////////////////////////////////////////// + /// find_as + /// In order to support the ability to have a tree of strings but + /// be able to do efficiently lookups via char pointers (i.e. so they + /// aren't converted to string objects), we provide the find_as + /// function. This function allows you to do a find with a key of a + /// type other than the tree's key type. See the find_as function + /// for more documentation on this. + /// + template + class rbtree + : public rb_base > + { + public: + typedef ptrdiff_t difference_type; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef Key key_type; + typedef Value value_type; + typedef rbtree_node node_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef typename type_select, + rbtree_iterator >::type iterator; + typedef rbtree_iterator const_iterator; + typedef eastl::reverse_iterator reverse_iterator; + typedef eastl::reverse_iterator const_reverse_iterator; + + typedef Allocator allocator_type; + typedef Compare key_compare; + typedef typename type_select, iterator>::type insert_return_type; // map/set::insert return a pair, multimap/multiset::iterator return an iterator. + typedef rbtree this_type; + typedef rb_base base_type; + typedef integral_constant has_unique_keys_type; + typedef typename base_type::extract_key extract_key; + + using base_type::mCompare; + + enum + { + kKeyAlignment = EASTL_ALIGN_OF(key_type), + kKeyAlignmentOffset = 0, // To do: Make sure this really is zero for all uses of this template. + kValueAlignment = EASTL_ALIGN_OF(value_type), + kValueAlignmentOffset = 0 // To fix: This offset is zero for sets and >0 for maps. Need to fix this. + }; + + public: + rbtree_node_base mAnchor; /// This node acts as end() and its mpLeft points to begin(), and mpRight points to rbegin() (the last node on the right). + size_type mnSize; /// Stores the count of nodes in the tree (not counting the anchor node). + allocator_type mAllocator; // To do: Use base class optimization to make this go away. + + public: + // ctor/dtor + rbtree(); + rbtree(const allocator_type& allocator); + rbtree(const Compare& compare, const allocator_type& allocator = EASTL_RBTREE_DEFAULT_ALLOCATOR); + rbtree(const this_type& x); + + template + rbtree(InputIterator first, InputIterator last, const Compare& compare, const allocator_type& allocator = EASTL_RBTREE_DEFAULT_ALLOCATOR); + + ~rbtree(); + + public: + // properties + allocator_type& get_allocator(); + void set_allocator(const allocator_type& allocator); + + const key_compare& key_comp() const { return mCompare; } + key_compare& key_comp() { return mCompare; } + + this_type& operator=(const this_type& x); + + void swap(this_type& x); + + public: + // iterators + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; + reverse_iterator rend(); + const_reverse_iterator rend() const; + + public: + bool empty() const; + size_type size() const; + + /// map::insert and set::insert return a pair, while multimap::insert and + /// multiset::insert return an iterator. + insert_return_type insert(const value_type& value); + + // C++ standard: inserts value if and only if there is no element with + // key equivalent to the key of t in containers with unique keys; always + // inserts value in containers with equivalent keys. Always returns the + // iterator pointing to the element with key equivalent to the key of value. + // iterator position is a hint pointing to where the insert should start + // to search. However, there is a potential defect/improvement report on this behaviour: + // LWG issue #233 (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1780.html) + // We follow the same approach as SGI STL/STLPort and use the position as + // a forced insertion position for the value when possible. + iterator insert(iterator position, const value_type& value); + + template + void insert(InputIterator first, InputIterator last); + + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + + // For some reason, multiple STL versions make a specialization + // for erasing an array of key_types. I'm pretty sure we don't + // need this, but just to be safe we will follow suit. + // The implementation is trivial. Returns void because the values + // could well be randomly distributed throughout the tree and thus + // a return value would be nearly meaningless. + void erase(const key_type* first, const key_type* last); + + void clear(); + void reset(); + + iterator find(const key_type& key); + const_iterator find(const key_type& key) const; + + /// Implements a find whereby the user supplies a comparison of a different type + /// than the tree's value_type. A useful case of this is one whereby you have + /// a container of string objects but want to do searches via passing in char pointers. + /// The problem is that without this kind of find, you need to do the expensive operation + /// of converting the char pointer to a string so it can be used as the argument to the + /// find function. + /// + /// Example usage (note that the compare uses string as first type and char* as second): + /// set strings; + /// strings.find_as("hello", less_2()); + /// + template + iterator find_as(const U& u, Compare2 compare2); + + template + const_iterator find_as(const U& u, Compare2 compare2) const; + + iterator lower_bound(const key_type& key); + const_iterator lower_bound(const key_type& key) const; + + iterator upper_bound(const key_type& key); + const_iterator upper_bound(const key_type& key) const; + + bool validate() const; + int validate_iterator(const_iterator i) const; + + protected: + node_type* DoAllocateNode(); + void DoFreeNode(node_type* pNode); + + node_type* DoCreateNodeFromKey(const key_type& key); + node_type* DoCreateNode(const value_type& value); + node_type* DoCreateNode(const node_type* pNodeSource, node_type* pNodeParent); + + node_type* DoCopySubtree(const node_type* pNodeSource, node_type* pNodeDest); + void DoNukeSubtree(node_type* pNode); + + // Intentionally return a pair and not an iterator for DoInsertValue(..., true_type) + // This is because the C++ standard for map and set is to return a pair and not just an iterator. + eastl::pair DoInsertValue(const value_type& value, true_type); // true_type means keys are unique. + iterator DoInsertValue(const value_type& value, false_type); // false_type means keys are not unique. + + eastl::pair DoInsertKey(const key_type& key, true_type); + iterator DoInsertKey(const key_type& key, false_type); + + iterator DoInsertValue(iterator position, const value_type& value, true_type); + iterator DoInsertValue(iterator position, const value_type& value, false_type); + + iterator DoInsertKey(iterator position, const key_type& key, true_type); + iterator DoInsertKey(iterator position, const key_type& key, false_type); + + iterator DoInsertValueImpl(node_type* pNodeParent, const value_type& value, bool bForceToLeft); + iterator DoInsertKeyImpl(node_type* pNodeParent, const key_type& key, bool bForceToLeft); + + }; // rbtree + + + + + + /////////////////////////////////////////////////////////////////////// + // rbtree_node_base functions + /////////////////////////////////////////////////////////////////////// + + EASTL_API inline rbtree_node_base* RBTreeGetMinChild(const rbtree_node_base* pNodeBase) + { + while(pNodeBase->mpNodeLeft) + pNodeBase = pNodeBase->mpNodeLeft; + return const_cast(pNodeBase); + } + + EASTL_API inline rbtree_node_base* RBTreeGetMaxChild(const rbtree_node_base* pNodeBase) + { + while(pNodeBase->mpNodeRight) + pNodeBase = pNodeBase->mpNodeRight; + return const_cast(pNodeBase); + } + + // The rest of the functions are non-trivial and are found in + // the corresponding .cpp file to this file. + + + + /////////////////////////////////////////////////////////////////////// + // rbtree_iterator functions + /////////////////////////////////////////////////////////////////////// + + template + rbtree_iterator::rbtree_iterator() + : mpNode(NULL) { } + + + template + rbtree_iterator::rbtree_iterator(const node_type* pNode) + : mpNode(static_cast(const_cast(pNode))) { } + + + template + rbtree_iterator::rbtree_iterator(const iterator& x) + : mpNode(x.mpNode) { } + + + template + typename rbtree_iterator::reference + rbtree_iterator::operator*() const + { return mpNode->mValue; } + + + template + typename rbtree_iterator::pointer + rbtree_iterator::operator->() const + { return &mpNode->mValue; } + + + template + typename rbtree_iterator::this_type& + rbtree_iterator::operator++() + { + mpNode = static_cast(RBTreeIncrement(mpNode)); + return *this; + } + + + template + typename rbtree_iterator::this_type + rbtree_iterator::operator++(int) + { + this_type temp(*this); + mpNode = static_cast(RBTreeIncrement(mpNode)); + return temp; + } + + + template + typename rbtree_iterator::this_type& + rbtree_iterator::operator--() + { + mpNode = static_cast(RBTreeDecrement(mpNode)); + return *this; + } + + + template + typename rbtree_iterator::this_type + rbtree_iterator::operator--(int) + { + this_type temp(*this); + mpNode = static_cast(RBTreeDecrement(mpNode)); + return temp; + } + + + // The C++ defect report #179 requires that we support comparisons between const and non-const iterators. + // Thus we provide additional template paremeters here to support this. The defect report does not + // require us to support comparisons between reverse_iterators and const_reverse_iterators. + template + inline bool operator==(const rbtree_iterator& a, + const rbtree_iterator& b) + { + return a.mpNode == b.mpNode; + } + + + template + inline bool operator!=(const rbtree_iterator& a, + const rbtree_iterator& b) + { + return a.mpNode != b.mpNode; + } + + + // We provide a version of operator!= for the case where the iterators are of the + // same type. This helps prevent ambiguity errors in the presence of rel_ops. + template + inline bool operator!=(const rbtree_iterator& a, + const rbtree_iterator& b) + { + return a.mpNode != b.mpNode; + } + + + + + /////////////////////////////////////////////////////////////////////// + // rbtree functions + /////////////////////////////////////////////////////////////////////// + + template + inline rbtree::rbtree() + : mAnchor(), + mnSize(0), + mAllocator(EASTL_RBTREE_DEFAULT_NAME) + { + reset(); + } + + + template + inline rbtree::rbtree(const allocator_type& allocator) + : mAnchor(), + mnSize(0), + mAllocator(allocator) + { + reset(); + } + + + template + inline rbtree::rbtree(const C& compare, const allocator_type& allocator) + : base_type(compare), + mAnchor(), + mnSize(0), + mAllocator(allocator) + { + reset(); + } + + + template + inline rbtree::rbtree(const this_type& x) + : base_type(x.mCompare), + mAnchor(), + mnSize(0), + mAllocator(x.mAllocator) + { + reset(); + + if(x.mAnchor.mpNodeParent) // mAnchor.mpNodeParent is the rb_tree root node. + { + mAnchor.mpNodeParent = DoCopySubtree((const node_type*)x.mAnchor.mpNodeParent, (node_type*)&mAnchor); + mAnchor.mpNodeRight = RBTreeGetMaxChild(mAnchor.mpNodeParent); + mAnchor.mpNodeLeft = RBTreeGetMinChild(mAnchor.mpNodeParent); + mnSize = x.mnSize; + } + } + + + template + template + inline rbtree::rbtree(InputIterator first, InputIterator last, const C& compare, const allocator_type& allocator) + : base_type(compare), + mAnchor(), + mnSize(0), + mAllocator(allocator) + { + reset(); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + for(; first != last; ++first) + insert(*first); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + clear(); + throw; + } + #endif + } + + + template + inline rbtree::~rbtree() + { + // Erase the entire tree. DoNukeSubtree is not a + // conventional erase function, as it does no rebalancing. + DoNukeSubtree((node_type*)mAnchor.mpNodeParent); + } + + + template + inline typename rbtree::allocator_type& + rbtree::get_allocator() + { + return mAllocator; + } + + + template + inline void rbtree::set_allocator(const allocator_type& allocator) + { + mAllocator = allocator; + } + + + template + inline typename rbtree::size_type + rbtree::size() const + { return mnSize; } + + + template + inline bool rbtree::empty() const + { return (mnSize == 0); } + + + template + inline typename rbtree::iterator + rbtree::begin() + { return iterator(static_cast(mAnchor.mpNodeLeft)); } + + + template + inline typename rbtree::const_iterator + rbtree::begin() const + { return const_iterator(static_cast(const_cast(mAnchor.mpNodeLeft))); } + + + template + inline typename rbtree::iterator + rbtree::end() + { return iterator(static_cast(&mAnchor)); } + + + template + inline typename rbtree::const_iterator + rbtree::end() const + { return const_iterator(static_cast(const_cast(&mAnchor))); } + + + template + inline typename rbtree::reverse_iterator + rbtree::rbegin() + { return reverse_iterator(end()); } + + + template + inline typename rbtree::const_reverse_iterator + rbtree::rbegin() const + { return const_reverse_iterator(end()); } + + + template + inline typename rbtree::reverse_iterator + rbtree::rend() + { return reverse_iterator(begin()); } + + + template + inline typename rbtree::const_reverse_iterator + rbtree::rend() const + { return const_reverse_iterator(begin()); } + + + template + inline typename rbtree::this_type& + rbtree::operator=(const this_type& x) + { + if(this != &x) + { + clear(); + + #if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; + #endif + + base_type::mCompare = x.mCompare; + + if(x.mAnchor.mpNodeParent) // mAnchor.mpNodeParent is the rb_tree root node. + { + mAnchor.mpNodeParent = DoCopySubtree((const node_type*)x.mAnchor.mpNodeParent, (node_type*)&mAnchor); + mAnchor.mpNodeRight = RBTreeGetMaxChild(mAnchor.mpNodeParent); + mAnchor.mpNodeLeft = RBTreeGetMinChild(mAnchor.mpNodeParent); + mnSize = x.mnSize; + } + } + return *this; + } + + + template + void rbtree::swap(this_type& x) + { + if(mAllocator == x.mAllocator) // If allocators are equivalent... + { + // Most of our members can be exchaged by a basic swap: + // We leave mAllocator as-is. + eastl::swap(mnSize, x.mnSize); + eastl::swap(base_type::mCompare, x.mCompare); + + // However, because our anchor node is a part of our class instance and not + // dynamically allocated, we can't do a swap of it but must do a more elaborate + // procedure. This is the downside to having the mAnchor be like this, but + // otherwise we consider it a good idea to avoid allocating memory for a + // nominal container instance. + + // We optimize for the expected most common case: both pointers being non-null. + if(mAnchor.mpNodeParent && x.mAnchor.mpNodeParent) // If both pointers are non-null... + { + eastl::swap(mAnchor.mpNodeRight, x.mAnchor.mpNodeRight); + eastl::swap(mAnchor.mpNodeLeft, x.mAnchor.mpNodeLeft); + eastl::swap(mAnchor.mpNodeParent, x.mAnchor.mpNodeParent); + + // We need to fix up the anchors to point to themselves (we can't just swap them). + mAnchor.mpNodeParent->mpNodeParent = &mAnchor; + x.mAnchor.mpNodeParent->mpNodeParent = &x.mAnchor; + } + else if(mAnchor.mpNodeParent) + { + x.mAnchor.mpNodeRight = mAnchor.mpNodeRight; + x.mAnchor.mpNodeLeft = mAnchor.mpNodeLeft; + x.mAnchor.mpNodeParent = mAnchor.mpNodeParent; + x.mAnchor.mpNodeParent->mpNodeParent = &x.mAnchor; + + // We need to fix up our anchor to point it itself (we can't have it swap with x). + mAnchor.mpNodeRight = &mAnchor; + mAnchor.mpNodeLeft = &mAnchor; + mAnchor.mpNodeParent = NULL; + } + else if(x.mAnchor.mpNodeParent) + { + mAnchor.mpNodeRight = x.mAnchor.mpNodeRight; + mAnchor.mpNodeLeft = x.mAnchor.mpNodeLeft; + mAnchor.mpNodeParent = x.mAnchor.mpNodeParent; + mAnchor.mpNodeParent->mpNodeParent = &mAnchor; + + // We need to fix up x's anchor to point it itself (we can't have it swap with us). + x.mAnchor.mpNodeRight = &x.mAnchor; + x.mAnchor.mpNodeLeft = &x.mAnchor; + x.mAnchor.mpNodeParent = NULL; + } // Else both are NULL and there is nothing to do. + } + else + { + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + } + } + + + template + inline typename rbtree::insert_return_type // map/set::insert return a pair, multimap/multiset::iterator return an iterator. + rbtree::insert(const value_type& value) + { return DoInsertValue(value, has_unique_keys_type()); } + + + template + typename rbtree::iterator + rbtree::insert(iterator position, const value_type& value) + { return DoInsertValue(position, value, has_unique_keys_type()); } + + + template + eastl::pair::iterator, bool> + rbtree::DoInsertValue(const value_type& value, true_type) // true_type means keys are unique. + { + // This is the pathway for insertion of unique keys (map and set, but not multimap and multiset). + // Note that we return a pair and not an iterator. This is because the C++ standard for map + // and set is to return a pair and not just an iterator. + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pLowerBound = (node_type*)&mAnchor; // Set it to the container end for now. + node_type* pParent; // This will be where we insert the new node. + + bool bValueLessThanNode = true; // If the tree is empty, this will result in an insertion at the front. + + // Find insertion position of the value. This will either be a position which + // already contains the value, a position which is greater than the value or + // end(), which we treat like a position which is greater than the value. + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + bValueLessThanNode = mCompare(extractKey(value), extractKey(pCurrent->mValue)); + pLowerBound = pCurrent; + + if(bValueLessThanNode) + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(pCurrent->mValue), extractKey(value))); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + + pParent = pLowerBound; // pLowerBound is actually upper bound right now (i.e. it is > value instead of <=), but we will make it the lower bound below. + + if(bValueLessThanNode) // If we ended up on the left side of the last parent node... + { + if(EASTL_LIKELY(pLowerBound != (node_type*)mAnchor.mpNodeLeft)) // If the tree was empty or if we otherwise need to insert at the very front of the tree... + { + // At this point, pLowerBound points to a node which is > than value. + // Move it back by one, so that it points to a node which is <= value. + pLowerBound = (node_type*)RBTreeDecrement(pLowerBound); + } + else + { + const iterator itResult(DoInsertValueImpl(pLowerBound, value, false)); + return pair(itResult, true); + } + } + + // Since here we require values to be unique, we will do nothing if the value already exists. + if(mCompare(extractKey(pLowerBound->mValue), extractKey(value))) // If the node is < the value (i.e. if value is >= the node)... + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(value), extractKey(pLowerBound->mValue))); // Validate that the compare function is sane. + const iterator itResult(DoInsertValueImpl(pParent, value, false)); + return pair(itResult, true); + } + + // The item already exists (as found by the compare directly above), so return false. + return pair(iterator(pLowerBound), false); + } + + + template + typename rbtree::iterator + rbtree::DoInsertValue(const value_type& value, false_type) // false_type means keys are not unique. + { + // This is the pathway for insertion of non-unique keys (multimap and multiset, but not map and set). + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + extract_key extractKey; + + while(pCurrent) + { + pRangeEnd = pCurrent; + + if(mCompare(extractKey(value), extractKey(pCurrent->mValue))) + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(pCurrent->mValue), extractKey(value))); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + + return DoInsertValueImpl(pRangeEnd, value, false); + } + + + template + eastl::pair::iterator, bool> + rbtree::DoInsertKey(const key_type& key, true_type) // true_type means keys are unique. + { + // This code is essentially a slightly modified copy of the the rbtree::insert + // function whereby this version takes a key and not a full value_type. + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pLowerBound = (node_type*)&mAnchor; // Set it to the container end for now. + node_type* pParent; // This will be where we insert the new node. + + bool bValueLessThanNode = true; // If the tree is empty, this will result in an insertion at the front. + + // Find insertion position of the value. This will either be a position which + // already contains the value, a position which is greater than the value or + // end(), which we treat like a position which is greater than the value. + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + bValueLessThanNode = mCompare(key, extractKey(pCurrent->mValue)); + pLowerBound = pCurrent; + + if(bValueLessThanNode) + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(pCurrent->mValue), key)); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + + pParent = pLowerBound; // pLowerBound is actually upper bound right now (i.e. it is > value instead of <=), but we will make it the lower bound below. + + if(bValueLessThanNode) // If we ended up on the left side of the last parent node... + { + if(EASTL_LIKELY(pLowerBound != (node_type*)mAnchor.mpNodeLeft)) // If the tree was empty or if we otherwise need to insert at the very front of the tree... + { + // At this point, pLowerBound points to a node which is > than value. + // Move it back by one, so that it points to a node which is <= value. + pLowerBound = (node_type*)RBTreeDecrement(pLowerBound); + } + else + { + const iterator itResult(DoInsertKeyImpl(pLowerBound, key, false)); + return pair(itResult, true); + } + } + + // Since here we require values to be unique, we will do nothing if the value already exists. + if(mCompare(extractKey(pLowerBound->mValue), key)) // If the node is < the value (i.e. if value is >= the node)... + { + EASTL_VALIDATE_COMPARE(!mCompare(key, extractKey(pLowerBound->mValue))); // Validate that the compare function is sane. + const iterator itResult(DoInsertKeyImpl(pParent, key, false)); + return pair(itResult, true); + } + + // The item already exists (as found by the compare directly above), so return false. + return pair(iterator(pLowerBound), false); + } + + + template + typename rbtree::iterator + rbtree::DoInsertKey(const key_type& key, false_type) // false_type means keys are not unique. + { + // This is the pathway for insertion of non-unique keys (multimap and multiset, but not map and set). + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + extract_key extractKey; + + while(pCurrent) + { + pRangeEnd = pCurrent; + + if(mCompare(key, extractKey(pCurrent->mValue))) + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(pCurrent->mValue), key)); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + + return DoInsertKeyImpl(pRangeEnd, key, false); + } + + + template + typename rbtree::iterator + rbtree::DoInsertValue(iterator position, const value_type& value, true_type) // true_type means keys are unique. + { + // This is the pathway for insertion of unique keys (map and set, but not multimap and multiset). + // + // We follow the same approach as SGI STL/STLPort and use the position as + // a forced insertion position for the value when possible. + extract_key extractKey; + + if((position.mpNode != mAnchor.mpNodeRight) && (position.mpNode != &mAnchor)) // If the user specified a specific insertion position... + { + iterator itNext(position); + ++itNext; + + // To consider: Change this so that 'position' specifies the position after + // where the insertion goes and not the position before where the insertion goes. + // Doing so would make this more in line with user expectations and with LWG #233. + const bool bPositionLessThanValue = mCompare(extractKey(position.mpNode->mValue), extractKey(value)); + + if(bPositionLessThanValue) // If (value > *position)... + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(value), extractKey(position.mpNode->mValue))); // Validate that the compare function is sane. + + const bool bValueLessThanNext = mCompare(extractKey(value), extractKey(itNext.mpNode->mValue)); + + if(bValueLessThanNext) // if (value < *itNext)... + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(itNext.mpNode->mValue), extractKey(value))); // Validate that the compare function is sane. + + if(position.mpNode->mpNodeRight) + return DoInsertValueImpl(itNext.mpNode, value, true); + return DoInsertValueImpl(position.mpNode, value, false); + } + } + + return DoInsertValue(value, has_unique_keys_type()).first; + } + + if(mnSize && mCompare(extractKey(((node_type*)mAnchor.mpNodeRight)->mValue), extractKey(value))) + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(value), extractKey(((node_type*)mAnchor.mpNodeRight)->mValue))); // Validate that the compare function is sane. + return DoInsertValueImpl((node_type*)mAnchor.mpNodeRight, value, false); + } + + return DoInsertValue(value, has_unique_keys_type()).first; + } + + + template + typename rbtree::iterator + rbtree::DoInsertValue(iterator position, const value_type& value, false_type) // false_type means keys are not unique. + { + // This is the pathway for insertion of non-unique keys (multimap and multiset, but not map and set). + // + // We follow the same approach as SGI STL/STLPort and use the position as + // a forced insertion position for the value when possible. + extract_key extractKey; + + if((position.mpNode != mAnchor.mpNodeRight) && (position.mpNode != &mAnchor)) // If the user specified a specific insertion position... + { + iterator itNext(position); + ++itNext; + + // To consider: Change this so that 'position' specifies the position after + // where the insertion goes and not the position before where the insertion goes. + // Doing so would make this more in line with user expectations and with LWG #233. + + if(!mCompare(extractKey(value), extractKey(position.mpNode->mValue)) && // If value >= *position && + !mCompare(extractKey(itNext.mpNode->mValue), extractKey(value))) // if value <= *itNext... + { + if(position.mpNode->mpNodeRight) // If there are any nodes to the right... [this expression will always be true as long as we aren't at the end()] + return DoInsertValueImpl(itNext.mpNode, value, true); // Specifically insert in front of (to the left of) itNext (and thus after 'position'). + return DoInsertValueImpl(position.mpNode, value, false); + } + + return DoInsertValue(value, has_unique_keys_type()); // If the above specified hint was not useful, then we do a regular insertion. + } + + // This pathway shouldn't be commonly executed, as the user shouldn't be calling + // this hinted version of insert if the user isn't providing a useful hint. + + if(mnSize && !mCompare(extractKey(value), extractKey(((node_type*)mAnchor.mpNodeRight)->mValue))) // If we are non-empty and the value is >= the last node... + return DoInsertValueImpl((node_type*)mAnchor.mpNodeRight, value, false); // Insert after the last node (doesn't matter if we force left or not). + + return DoInsertValue(value, has_unique_keys_type()); // We are empty or we are inserting at the end. + } + + + template + typename rbtree::iterator + rbtree::DoInsertKey(iterator position, const key_type& key, true_type) // true_type means keys are unique. + { + // This is the pathway for insertion of unique keys (map and set, but not multimap and multiset). + // + // We follow the same approach as SGI STL/STLPort and use the position as + // a forced insertion position for the value when possible. + extract_key extractKey; + + if((position.mpNode != mAnchor.mpNodeRight) && (position.mpNode != &mAnchor)) // If the user specified a specific insertion position... + { + iterator itNext(position); + ++itNext; + + // To consider: Change this so that 'position' specifies the position after + // where the insertion goes and not the position before where the insertion goes. + // Doing so would make this more in line with user expectations and with LWG #233. + const bool bPositionLessThanValue = mCompare(extractKey(position.mpNode->mValue), key); + + if(bPositionLessThanValue) // If (value > *position)... + { + EASTL_VALIDATE_COMPARE(!mCompare(key, extractKey(position.mpNode->mValue))); // Validate that the compare function is sane. + + const bool bValueLessThanNext = mCompare(key, extractKey(itNext.mpNode->mValue)); + + if(bValueLessThanNext) // If value < *itNext... + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(itNext.mpNode->mValue), key)); // Validate that the compare function is sane. + + if(position.mpNode->mpNodeRight) + return DoInsertKeyImpl(itNext.mpNode, key, true); + return DoInsertKeyImpl(position.mpNode, key, false); + } + } + + return DoInsertKey(key, has_unique_keys_type()).first; + } + + if(mnSize && mCompare(extractKey(((node_type*)mAnchor.mpNodeRight)->mValue), key)) + { + EASTL_VALIDATE_COMPARE(!mCompare(key, extractKey(((node_type*)mAnchor.mpNodeRight)->mValue))); // Validate that the compare function is sane. + return DoInsertKeyImpl((node_type*)mAnchor.mpNodeRight, key, false); + } + + return DoInsertKey(key, has_unique_keys_type()).first; + } + + + template + typename rbtree::iterator + rbtree::DoInsertKey(iterator position, const key_type& key, false_type) // false_type means keys are not unique. + { + // This is the pathway for insertion of non-unique keys (multimap and multiset, but not map and set). + // + // We follow the same approach as SGI STL/STLPort and use the position as + // a forced insertion position for the value when possible. + extract_key extractKey; + + if((position.mpNode != mAnchor.mpNodeRight) && (position.mpNode != &mAnchor)) // If the user specified a specific insertion position... + { + iterator itNext(position); + ++itNext; + + // To consider: Change this so that 'position' specifies the position after + // where the insertion goes and not the position before where the insertion goes. + // Doing so would make this more in line with user expectations and with LWG #233. + if(!mCompare(key, extractKey(position.mpNode->mValue)) && // If value >= *position && + !mCompare(extractKey(itNext.mpNode->mValue), key)) // if value <= *itNext... + { + if(position.mpNode->mpNodeRight) // If there are any nodes to the right... [this expression will always be true as long as we aren't at the end()] + return DoInsertKeyImpl(itNext.mpNode, key, true); // Specifically insert in front of (to the left of) itNext (and thus after 'position'). + return DoInsertKeyImpl(position.mpNode, key, false); + } + + return DoInsertKey(key, has_unique_keys_type()); // If the above specified hint was not useful, then we do a regular insertion. + } + + // This pathway shouldn't be commonly executed, as the user shouldn't be calling + // this hinted version of insert if the user isn't providing a useful hint. + if(mnSize && !mCompare(key, extractKey(((node_type*)mAnchor.mpNodeRight)->mValue))) // If we are non-empty and the value is >= the last node... + return DoInsertKeyImpl((node_type*)mAnchor.mpNodeRight, key, false); // Insert after the last node (doesn't matter if we force left or not). + + return DoInsertKey(key, has_unique_keys_type()); // We are empty or we are inserting at the end. + } + + + template + typename rbtree::iterator + rbtree::DoInsertValueImpl(node_type* pNodeParent, const value_type& value, bool bForceToLeft) + { + RBTreeSide side; + extract_key extractKey; + + // The reason we may want to have bForceToLeft == true is that pNodeParent->mValue and value may be equal. + // In that case it doesn't matter what side we insert on, except that the C++ LWG #233 improvement report + // suggests that we should use the insert hint position to force an ordering. So that's what we do. + if(bForceToLeft || (pNodeParent == &mAnchor) || mCompare(extractKey(value), extractKey(pNodeParent->mValue))) + side = kRBTreeSideLeft; + else + side = kRBTreeSideRight; + + node_type* const pNodeNew = DoCreateNode(value); // Note that pNodeNew->mpLeft, mpRight, mpParent, will be uninitialized. + RBTreeInsert(pNodeNew, pNodeParent, &mAnchor, side); + mnSize++; + + return iterator(pNodeNew); + } + + + template + typename rbtree::iterator + rbtree::DoInsertKeyImpl(node_type* pNodeParent, const key_type& key, bool bForceToLeft) + { + RBTreeSide side; + extract_key extractKey; + + // The reason we may want to have bForceToLeft == true is that pNodeParent->mValue and value may be equal. + // In that case it doesn't matter what side we insert on, except that the C++ LWG #233 improvement report + // suggests that we should use the insert hint position to force an ordering. So that's what we do. + if(bForceToLeft || (pNodeParent == &mAnchor) || mCompare(key, extractKey(pNodeParent->mValue))) + side = kRBTreeSideLeft; + else + side = kRBTreeSideRight; + + node_type* const pNodeNew = DoCreateNodeFromKey(key); // Note that pNodeNew->mpLeft, mpRight, mpParent, will be uninitialized. + RBTreeInsert(pNodeNew, pNodeParent, &mAnchor, side); + mnSize++; + + return iterator(pNodeNew); + } + + + template + template + void rbtree::insert(InputIterator first, InputIterator last) + { + for( ; first != last; ++first) + DoInsertValue(*first, has_unique_keys_type()); // Or maybe we should call 'insert(end(), *first)' instead. If the first-last range was sorted then this might make some sense. + } + + + template + inline void rbtree::clear() + { + // Erase the entire tree. DoNukeSubtree is not a + // conventional erase function, as it does no rebalancing. + DoNukeSubtree((node_type*)mAnchor.mpNodeParent); + reset(); + } + + + template + inline void rbtree::reset() + { + // The reset function is a special extension function which unilaterally + // resets the container to an empty state without freeing the memory of + // the contained objects. This is useful for very quickly tearing down a + // container built into scratch memory. + mAnchor.mpNodeRight = &mAnchor; + mAnchor.mpNodeLeft = &mAnchor; + mAnchor.mpNodeParent = NULL; + mAnchor.mColor = kRBTreeColorRed; + mnSize = 0; + } + + + template + inline typename rbtree::iterator + rbtree::erase(iterator position) + { + const iterator iErase(position); + --mnSize; // Interleave this between the two references to itNext. We expect no exceptions to occur during the code below. + ++position; + RBTreeErase(iErase.mpNode, &mAnchor); + DoFreeNode(iErase.mpNode); + return position; + } + + + template + typename rbtree::iterator + rbtree::erase(iterator first, iterator last) + { + // We expect that if the user means to clear the container, they will call clear. + if(EASTL_LIKELY((first.mpNode != mAnchor.mpNodeLeft) || (last.mpNode != &mAnchor))) // If (first != begin or last != end) ... + { + // Basic implementation: + while(first != last) + first = erase(first); + return first; + + // Inlined implementation: + //size_type n = 0; + //while(first != last) + //{ + // const iterator itErase(first); + // ++n; + // ++first; + // RBTreeErase(itErase.mpNode, &mAnchor); + // DoFreeNode(itErase.mpNode); + //} + //mnSize -= n; + //return first; + } + + clear(); + return iterator((node_type*)&mAnchor); // Same as: return end(); + } + + + template + inline typename rbtree::reverse_iterator + rbtree::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + typename rbtree::reverse_iterator + rbtree::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + inline void rbtree::erase(const key_type* first, const key_type* last) + { + // We have no choice but to run a loop like this, as the first/last range could + // have values that are discontiguously located in the tree. And some may not + // even be in the tree. + while(first != last) + erase(*first++); + } + + + template + typename rbtree::iterator + rbtree::find(const key_type& key) + { + // To consider: Implement this instead via calling lower_bound and + // inspecting the result. The following is an implementation of this: + // const iterator it(lower_bound(key)); + // return ((it.mpNode == &mAnchor) || mCompare(key, extractKey(it.mpNode->mValue))) ? iterator(&mAnchor) : it; + // We don't currently implement the above because in practice people tend to call + // find a lot with trees, but very uncommonly call lower_bound. + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + if(EASTL_LIKELY(!mCompare(extractKey(pCurrent->mValue), key))) // If pCurrent is >= key... + { + pRangeEnd = pCurrent; + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + { + EASTL_VALIDATE_COMPARE(!mCompare(key, extractKey(pCurrent->mValue))); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + } + + if(EASTL_LIKELY((pRangeEnd != &mAnchor) && !mCompare(key, extractKey(pRangeEnd->mValue)))) + return iterator(pRangeEnd); + return iterator((node_type*)&mAnchor); + } + + + template + inline typename rbtree::const_iterator + rbtree::find(const key_type& key) const + { + typedef rbtree rbtree_type; + return const_iterator(const_cast(this)->find(key)); + } + + + template + template + typename rbtree::iterator + rbtree::find_as(const U& u, Compare2 compare2) + { + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + if(EASTL_LIKELY(!compare2(extractKey(pCurrent->mValue), u))) // If pCurrent is >= u... + { + pRangeEnd = pCurrent; + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + { + EASTL_VALIDATE_COMPARE(!compare2(u, extractKey(pCurrent->mValue))); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + } + + if(EASTL_LIKELY((pRangeEnd != &mAnchor) && !compare2(u, extractKey(pRangeEnd->mValue)))) + return iterator(pRangeEnd); + return iterator((node_type*)&mAnchor); + } + + + template + template + inline typename rbtree::const_iterator + rbtree::find_as(const U& u, Compare2 compare2) const + { + typedef rbtree rbtree_type; + return const_iterator(const_cast(this)->find_as(u, compare2)); + } + + + template + typename rbtree::iterator + rbtree::lower_bound(const key_type& key) + { + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + if(EASTL_LIKELY(!mCompare(extractKey(pCurrent->mValue), key))) // If pCurrent is >= key... + { + pRangeEnd = pCurrent; + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + { + EASTL_VALIDATE_COMPARE(!mCompare(key, extractKey(pCurrent->mValue))); // Validate that the compare function is sane. + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + } + + return iterator(pRangeEnd); + } + + + template + inline typename rbtree::const_iterator + rbtree::lower_bound(const key_type& key) const + { + typedef rbtree rbtree_type; + return const_iterator(const_cast(this)->lower_bound(key)); + } + + + template + typename rbtree::iterator + rbtree::upper_bound(const key_type& key) + { + extract_key extractKey; + + node_type* pCurrent = (node_type*)mAnchor.mpNodeParent; // Start with the root node. + node_type* pRangeEnd = (node_type*)&mAnchor; // Set it to the container end for now. + + while(EASTL_LIKELY(pCurrent)) // Do a walk down the tree. + { + if(EASTL_LIKELY(mCompare(key, extractKey(pCurrent->mValue)))) // If key is < pCurrent... + { + EASTL_VALIDATE_COMPARE(!mCompare(extractKey(pCurrent->mValue), key)); // Validate that the compare function is sane. + pRangeEnd = pCurrent; + pCurrent = (node_type*)pCurrent->mpNodeLeft; + } + else + pCurrent = (node_type*)pCurrent->mpNodeRight; + } + + return iterator(pRangeEnd); + } + + + template + inline typename rbtree::const_iterator + rbtree::upper_bound(const key_type& key) const + { + typedef rbtree rbtree_type; + return const_iterator(const_cast(this)->upper_bound(key)); + } + + + // To do: Move this validate function entirely to a template-less implementation. + template + bool rbtree::validate() const + { + // Red-black trees have the following canonical properties which we validate here: + // 1 Every node is either red or black. + // 2 Every leaf (NULL) is black by defintion. Any number of black nodes may appear in a sequence. + // 3 If a node is red, then both its children are black. Thus, on any path from + // the root to a leaf, red nodes must not be adjacent. + // 4 Every simple path from a node to a descendant leaf contains the same number of black nodes. + // 5 The mnSize member of the tree must equal the number of nodes in the tree. + // 6 The tree is sorted as per a conventional binary tree. + // 7 The comparison function is sane; it obeys strict weak ordering. If mCompare(a,b) is true, then mCompare(b,a) must be false. Both cannot be true. + + extract_key extractKey; + + if(mnSize) + { + // Verify basic integrity. + //if(!mAnchor.mpNodeParent || (mAnchor.mpNodeLeft == mAnchor.mpNodeRight)) + // return false; // Fix this for case of empty tree. + + if(mAnchor.mpNodeLeft != RBTreeGetMinChild(mAnchor.mpNodeParent)) + return false; + + if(mAnchor.mpNodeRight != RBTreeGetMaxChild(mAnchor.mpNodeParent)) + return false; + + const size_t nBlackCount = RBTreeGetBlackCount(mAnchor.mpNodeParent, mAnchor.mpNodeLeft); + size_type nIteratedSize = 0; + + for(const_iterator it = begin(); it != end(); ++it, ++nIteratedSize) + { + const node_type* const pNode = (const node_type*)it.mpNode; + const node_type* const pNodeRight = (const node_type*)pNode->mpNodeRight; + const node_type* const pNodeLeft = (const node_type*)pNode->mpNodeLeft; + + // Verify #7 above. + if(pNodeRight && mCompare(extractKey(pNodeRight->mValue), extractKey(pNode->mValue)) && mCompare(extractKey(pNode->mValue), extractKey(pNodeRight->mValue))) // Validate that the compare function is sane. + return false; + + // Verify #7 above. + if(pNodeLeft && mCompare(extractKey(pNodeLeft->mValue), extractKey(pNode->mValue)) && mCompare(extractKey(pNode->mValue), extractKey(pNodeLeft->mValue))) // Validate that the compare function is sane. + return false; + + // Verify item #1 above. + if((pNode->mColor != kRBTreeColorRed) && (pNode->mColor != kRBTreeColorBlack)) + return false; + + // Verify item #3 above. + if(pNode->mColor == kRBTreeColorRed) + { + if((pNodeRight && (pNodeRight->mColor == kRBTreeColorRed)) || + (pNodeLeft && (pNodeLeft->mColor == kRBTreeColorRed))) + return false; + } + + // Verify item #6 above. + if(pNodeRight && mCompare(extractKey(pNodeRight->mValue), extractKey(pNode->mValue))) + return false; + + if(pNodeLeft && mCompare(extractKey(pNode->mValue), extractKey(pNodeLeft->mValue))) + return false; + + if(!pNodeRight && !pNodeLeft) // If we are at a bottom node of the tree... + { + // Verify item #4 above. + if(RBTreeGetBlackCount(mAnchor.mpNodeParent, pNode) != nBlackCount) + return false; + } + } + + // Verify item #5 above. + if(nIteratedSize != mnSize) + return false; + + return true; + } + else + { + if((mAnchor.mpNodeLeft != &mAnchor) || (mAnchor.mpNodeRight != &mAnchor)) + return false; + } + + return true; + } + + + template + inline int rbtree::validate_iterator(const_iterator i) const + { + // To do: Come up with a more efficient mechanism of doing this. + + for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp) + { + if(temp == i) + return (isf_valid | isf_current | isf_can_dereference); + } + + if(i == end()) + return (isf_valid | isf_current); + + return isf_none; + } + + + template + inline typename rbtree::node_type* + rbtree::DoAllocateNode() + { + return (node_type*)allocate_memory(mAllocator, sizeof(node_type), kValueAlignment, kValueAlignmentOffset); + } + + + template + inline void rbtree::DoFreeNode(node_type* pNode) + { + pNode->~node_type(); + EASTLFree(mAllocator, pNode, sizeof(node_type)); + } + + + template + typename rbtree::node_type* + rbtree::DoCreateNodeFromKey(const key_type& key) + { + // Note that this function intentionally leaves the node pointers uninitialized. + // The caller would otherwise just turn right around and modify them, so there's + // no point in us initializing them to anything (except in a debug build). + node_type* const pNode = DoAllocateNode(); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + ::new(&pNode->mValue) value_type(key); + + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + DoFreeNode(pNode); + throw; + } + #endif + + #if EASTL_DEBUG + pNode->mpNodeRight = NULL; + pNode->mpNodeLeft = NULL; + pNode->mpNodeParent = NULL; + pNode->mColor = kRBTreeColorBlack; + #endif + + return pNode; + } + + + template + typename rbtree::node_type* + rbtree::DoCreateNode(const value_type& value) + { + // Note that this function intentionally leaves the node pointers uninitialized. + // The caller would otherwise just turn right around and modify them, so there's + // no point in us initializing them to anything (except in a debug build). + node_type* const pNode = DoAllocateNode(); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + ::new(&pNode->mValue) value_type(value); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + DoFreeNode(pNode); + throw; + } + #endif + + #if EASTL_DEBUG + pNode->mpNodeRight = NULL; + pNode->mpNodeLeft = NULL; + pNode->mpNodeParent = NULL; + pNode->mColor = kRBTreeColorBlack; + #endif + + return pNode; + } + + + template + typename rbtree::node_type* + rbtree::DoCreateNode(const node_type* pNodeSource, node_type* pNodeParent) + { + node_type* const pNode = DoCreateNode(pNodeSource->mValue); + + pNode->mpNodeRight = NULL; + pNode->mpNodeLeft = NULL; + pNode->mpNodeParent = pNodeParent; + pNode->mColor = pNodeSource->mColor; + + return pNode; + } + + + template + typename rbtree::node_type* + rbtree::DoCopySubtree(const node_type* pNodeSource, node_type* pNodeDest) + { + node_type* const pNewNodeRoot = DoCreateNode(pNodeSource, pNodeDest); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + // Copy the right side of the tree recursively. + if(pNodeSource->mpNodeRight) + pNewNodeRoot->mpNodeRight = DoCopySubtree((const node_type*)pNodeSource->mpNodeRight, pNewNodeRoot); + + node_type* pNewNodeLeft; + + for(pNodeSource = (node_type*)pNodeSource->mpNodeLeft, pNodeDest = pNewNodeRoot; + pNodeSource; + pNodeSource = (node_type*)pNodeSource->mpNodeLeft, pNodeDest = pNewNodeLeft) + { + pNewNodeLeft = DoCreateNode(pNodeSource, pNodeDest); + + pNodeDest->mpNodeLeft = pNewNodeLeft; + + // Copy the right side of the tree recursively. + if(pNodeSource->mpNodeRight) + pNewNodeLeft->mpNodeRight = DoCopySubtree((const node_type*)pNodeSource->mpNodeRight, pNewNodeLeft); + } + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + DoNukeSubtree(pNewNodeRoot); + throw; + } + #endif + + return pNewNodeRoot; + } + + + template + void rbtree::DoNukeSubtree(node_type* pNode) + { + while(pNode) // Recursively traverse the tree and destroy items as we go. + { + DoNukeSubtree((node_type*)pNode->mpNodeRight); + + node_type* const pNodeLeft = (node_type*)pNode->mpNodeLeft; + DoFreeNode(pNode); + pNode = pNodeLeft; + } + } + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const rbtree& a, const rbtree& b) + { + return (a.size() == b.size()) && eastl::equal(a.begin(), a.end(), b.begin()); + } + + + // Note that in operator< we do comparisons based on the tree value_type with operator<() of the + // value_type instead of the tree's Compare function. For set/multiset, the value_type is T, while + // for map/multimap the value_type is a pair. operator< for pair can be seen by looking + // utility.h, but it basically is uses the operator< for pair.first and pair.second. The C++ standard + // appears to require this behaviour, whether intentionally or not. If anything, a good reason to do + // this is for consistency. A map and a vector that contain the same items should compare the same. + template + inline bool operator<(const rbtree& a, const rbtree& b) + { + return eastl::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); + } + + + template + inline bool operator!=(const rbtree& a, const rbtree& b) + { + return !(a == b); + } + + + template + inline bool operator>(const rbtree& a, const rbtree& b) + { + return b < a; + } + + + template + inline bool operator<=(const rbtree& a, const rbtree& b) + { + return !(b < a); + } + + + template + inline bool operator>=(const rbtree& a, const rbtree& b) + { + return !(a < b); + } + + + template + inline void swap(rbtree& a, rbtree& b) + { + a.swap(b); + } + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/type_compound.h b/lib/eastl/include/EASTL/internal/type_compound.h new file mode 100644 index 0000000..8bbe9ae --- /dev/null +++ b/lib/eastl/include/EASTL/internal/type_compound.h @@ -0,0 +1,485 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/type_compound.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_TYPE_COMPOUND_H +#define EASTL_INTERNAL_TYPE_COMPOUND_H + + +namespace eastl +{ + + // The following properties or relations are defined here. If the given + // item is missing then it simply hasn't been implemented, at least not yet. + // is_array + // is_pointer + // is_reference + // is_member_object_pointer + // is_member_function_pointer + // is_member_pointer + // is_enum + // is_union + // is_class + // is_polymorphic + // is_function + // is_object + // is_scalar + // is_compound + // is_same + // is_convertible + + /////////////////////////////////////////////////////////////////////// + // is_array + // + // is_array::value == true if and only if T is an array type. + // As of this writing, the SNC compiler (EDG-based) doesn't compile + // the code below and says that returning an array is illegal. + // + /////////////////////////////////////////////////////////////////////// + template + T (*is_array_tester1(empty))(empty); + char is_array_tester1(...); // May need to use __cdecl under VC++. + + template + no_type is_array_tester2(T(*)(empty)); + yes_type is_array_tester2(...); // May need to use __cdecl under VC++. + + template + struct is_array_helper { + static empty emptyInstance; + }; + + template + struct is_array : public integral_constant::emptyInstance))) == 1 + >{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_reference + // + // is_reference::value == true if and only if T is a reference type. + // This category includes reference to function types. + // + /////////////////////////////////////////////////////////////////////// + template struct is_reference : public false_type{}; + template struct is_reference : public true_type{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_member_function_pointer + // + // is_member_function_pointer::value == true if and only if T is a + // pointer to member function type. + // + /////////////////////////////////////////////////////////////////////// + // We detect member functions with 0 to N arguments. We can extend this + // for additional arguments if necessary. + // To do: Make volatile and const volatile versions of these in addition to non-const and const. + /////////////////////////////////////////////////////////////////////// + template struct is_mem_fun_pointer_value : public false_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + template struct is_mem_fun_pointer_value : public true_type{}; + + template + struct is_member_function_pointer : public integral_constant::value>{}; + + + /////////////////////////////////////////////////////////////////////// + // is_member_pointer + // + // is_member_pointer::value == true if and only if: + // is_member_object_pointer::value == true, or + // is_member_function_pointer::value == true + // + /////////////////////////////////////////////////////////////////////// + template + struct is_member_pointer : public integral_constant::value>{}; + + template struct is_member_pointer : public true_type{}; + + + + + /////////////////////////////////////////////////////////////////////// + // is_pointer + // + // is_pointer::value == true if and only if T is a pointer type. + // This category includes function pointer types, but not pointer to + // member types. + // + /////////////////////////////////////////////////////////////////////// + template struct is_pointer_helper : public false_type{}; + + template struct is_pointer_helper : public true_type{}; + template struct is_pointer_helper : public true_type{}; + template struct is_pointer_helper : public true_type{}; + template struct is_pointer_helper : public true_type{}; + + template + struct is_pointer_value : public type_and::value, type_not::value>::value> {}; + + template + struct is_pointer : public integral_constant::value>{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_same + // + // Given two (possibly identical) types T and U, is_same::value == true + // if and only if T and U are the same type. + // + /////////////////////////////////////////////////////////////////////// + template + struct is_same : public false_type { }; + + template + struct is_same : public true_type { }; + + + /////////////////////////////////////////////////////////////////////// + // is_convertible + // + // Given two (possible identical) types From and To, is_convertible::value == true + // if and only if an lvalue of type From can be implicitly converted to type To, + // or is_void::value == true + // + // is_convertible may only be applied to complete types. + // Type To may not be an abstract type. + // If the conversion is ambiguous, the program is ill-formed. + // If either or both of From and To are class types, and the conversion would invoke + // non-public member functions of either From or To (such as a private constructor of To, + // or a private conversion operator of From), the program is ill-formed. + // + // Note that without compiler help, both is_convertible and is_base + // can produce compiler errors if the conversion is ambiguous. + // Example: + // struct A {}; + // struct B : A {}; + // struct C : A {}; + // struct D : B, C {}; + // is_convertible::value; // Generates compiler error. + /////////////////////////////////////////////////////////////////////// + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x doesn't like the code below. + template + struct is_convertible_helper { + static yes_type Test(To); // May need to use __cdecl under VC++. + static no_type Test(...); // May need to use __cdecl under VC++. + static From from; + typedef integral_constant result; + }; + + // void is not convertible to non-void + template + struct is_convertible_helper { typedef false_type result; }; + + // Anything is convertible to void + template + struct is_convertible_helper { typedef true_type result; }; + + template + struct is_convertible : public is_convertible_helper::value, is_void::value>::result {}; + + #else + template + struct is_convertible : public false_type{}; + #endif + + + /////////////////////////////////////////////////////////////////////// + // is_union + // + // is_union::value == true if and only if T is a union type. + // + // There is no way to tell if a type is a union without compiler help. + // As of this writing, only Metrowerks v8+ supports such functionality + // via 'msl::is_union::value'. The user can force something to be + // evaluated as a union via EASTL_DECLARE_UNION. + /////////////////////////////////////////////////////////////////////// + template struct is_union : public false_type{}; + + #define EASTL_DECLARE_UNION(T) namespace eastl{ template <> struct is_union : public true_type{}; template <> struct is_union : public true_type{}; } + + + + + /////////////////////////////////////////////////////////////////////// + // is_class + // + // is_class::value == true if and only if T is a class or struct + // type (and not a union type). + // + // Without specific compiler help, it is not possible to + // distinguish between unions and classes. As a result, is_class + // will erroneously evaluate to true for union types. + /////////////////////////////////////////////////////////////////////// + #if defined(__MWERKS__) + // To do: Switch this to use msl_utility type traits. + template + struct is_class : public false_type{}; + #elif !defined(__GNUC__) || (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) // Not GCC or GCC 3.4+ + template static yes_type is_class_helper(void (U::*)()); + template static no_type is_class_helper(...); + + template + struct is_class : public integral_constant(0)) == sizeof(yes_type) && !is_union::value + >{}; + #else + // GCC 2.x version, due to GCC being broken. + template + struct is_class : public false_type{}; + #endif + + + + /////////////////////////////////////////////////////////////////////// + // is_enum + // + // is_enum::value == true if and only if T is an enumeration type. + // + /////////////////////////////////////////////////////////////////////// + struct int_convertible{ int_convertible(int); }; + + template + struct is_enum_helper { template struct nest : public is_convertible{}; }; + + template <> + struct is_enum_helper { template struct nest : public false_type {}; }; + + template + struct is_enum_helper2 + { + typedef type_or::value, is_reference::value, is_class::value> selector; + typedef is_enum_helper helper_t; + typedef typename add_reference::type ref_t; + typedef typename helper_t::template nest result; + }; + + template + struct is_enum : public integral_constant::result::value>{}; + + template <> struct is_enum : public false_type {}; + template <> struct is_enum : public false_type {}; + template <> struct is_enum : public false_type {}; + template <> struct is_enum : public false_type {}; + + #define EASTL_DECLARE_ENUM(T) namespace eastl{ template <> struct is_enum : public true_type{}; template <> struct is_enum : public true_type{}; } + + + /////////////////////////////////////////////////////////////////////// + // is_polymorphic + // + // is_polymorphic::value == true if and only if T is a class or struct + // that declares or inherits a virtual function. is_polymorphic may only + // be applied to complete types. + // + /////////////////////////////////////////////////////////////////////// + template + struct is_polymorphic_imp1 + { + typedef typename remove_cv::type t; + + struct helper_1 : public t + { + helper_1(); + ~helper_1() throw(); + char pad[64]; + }; + + struct helper_2 : public t + { + helper_2(); + virtual ~helper_2() throw(); + #ifndef _MSC_VER + virtual void foo(); + #endif + char pad[64]; + }; + + static const bool value = (sizeof(helper_1) == sizeof(helper_2)); + }; + + template + struct is_polymorphic_imp2{ static const bool value = false; }; + + template + struct is_polymorphic_selector{ template struct rebind{ typedef is_polymorphic_imp2 type; }; }; + + template <> + struct is_polymorphic_selector{ template struct rebind{ typedef is_polymorphic_imp1 type; }; }; + + template + struct is_polymorphic_value{ + typedef is_polymorphic_selector::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type imp_type; + static const bool value = imp_type::value; + }; + + template + struct is_polymorphic : public integral_constant::value>{}; + + + + + /////////////////////////////////////////////////////////////////////// + // is_function + // + // is_function::value == true if and only if T is a function type. + // + /////////////////////////////////////////////////////////////////////// + template struct is_function_ptr_helper : public false_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + template struct is_function_ptr_helper : public true_type{}; + + template + struct is_function_chooser{ template struct result_ : public false_type{}; }; + + template <> + struct is_function_chooser{ template struct result_ : public is_function_ptr_helper{}; }; + + template + struct is_function_value : public is_function_chooser::value>::template result_{}; + + template + struct is_function : public integral_constant::value>{}; + + + + + /////////////////////////////////////////////////////////////////////// + // is_object + // + // is_object::value == true if and only if: + // is_reference::value == false, and + // is_function::value == false, and + // is_void::value == false + // + // The C++ standard, section 3.9p9, states: "An object type is a + // (possibly cv-qualified) type that is not a function type, not a + // reference type, and not incomplete (except for an incompletely + // defined object type). + /////////////////////////////////////////////////////////////////////// + + template + struct is_object : public integral_constant::value && !is_void::value && !is_function::value + >{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_scalar + // + // is_scalar::value == true if and only if: + // is_arithmetic::value == true, or + // is_enum::value == true, or + // is_pointer::value == true, or + // is_member_pointer::value + // + /////////////////////////////////////////////////////////////////////// + template + struct is_scalar : public integral_constant::value || is_enum::value>{}; + + template struct is_scalar : public true_type {}; + template struct is_scalar : public true_type {}; + template struct is_scalar : public true_type {}; + template struct is_scalar : public true_type {}; + + + + /////////////////////////////////////////////////////////////////////// + // is_compound + // + // Compound means anything but fundamental. See C++ standard, section 3.9.2. + // + // is_compound::value == true if and only if: + // is_fundamental::value == false + // + // Thus, is_compound::value == true if and only if: + // is_floating_point::value == false, and + // is_integral::value == false, and + // is_void::value == false + // + /////////////////////////////////////////////////////////////////////// + template + struct is_compound : public integral_constant::value>{}; + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/type_fundamental.h b/lib/eastl/include/EASTL/internal/type_fundamental.h new file mode 100644 index 0000000..cc39865 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/type_fundamental.h @@ -0,0 +1,187 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/type_fundamental.h +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_TYPE_FUNDAMENTAL_H +#define EASTL_INTERNAL_TYPE_FUNDAMENTAL_H + + +namespace eastl +{ + + // The following properties or relations are defined here. If the given + // item is missing then it simply hasn't been implemented, at least not yet. + + + /////////////////////////////////////////////////////////////////////// + // is_void + // + // is_void::value == true if and only if T is one of the following types: + // [const][volatile] void + // + /////////////////////////////////////////////////////////////////////// + template struct is_void : public false_type{}; + + template <> struct is_void : public true_type{}; + template <> struct is_void : public true_type{}; + template <> struct is_void : public true_type{}; + template <> struct is_void : public true_type{}; + + + /////////////////////////////////////////////////////////////////////// + // is_integral + // + // is_integral::value == true if and only if T is one of the following types: + // [const] [volatile] bool + // [const] [volatile] char + // [const] [volatile] signed char + // [const] [volatile] unsigned char + // [const] [volatile] wchar_t + // [const] [volatile] short + // [const] [volatile] int + // [const] [volatile] long + // [const] [volatile] long long + // [const] [volatile] unsigned short + // [const] [volatile] unsigned int + // [const] [volatile] unsigned long + // [const] [volatile] unsigned long long + // + /////////////////////////////////////////////////////////////////////// + template struct is_integral : public false_type{}; + + // To do: Need to define volatile and const volatile versions of these. + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + template <> struct is_integral : public true_type{}; + template <> struct is_integral : public true_type{}; + #endif + + /////////////////////////////////////////////////////////////////////// + // is_floating_point + // + // is_floating_point::value == true if and only if T is one of the following types: + // [const] [volatile] float + // [const] [volatile] double + // [const] [volatile] long double + // + /////////////////////////////////////////////////////////////////////// + template struct is_floating_point : public false_type{}; + + // To do: Need to define volatile and const volatile versions of these. + template <> struct is_floating_point : public true_type{}; + template <> struct is_floating_point : public true_type{}; + template <> struct is_floating_point : public true_type{}; + template <> struct is_floating_point : public true_type{}; + template <> struct is_floating_point : public true_type{}; + template <> struct is_floating_point : public true_type{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_arithmetic + // + // is_arithmetic::value == true if and only if: + // is_floating_point::value == true, or + // is_integral::value == true + // + /////////////////////////////////////////////////////////////////////// + template + struct is_arithmetic : public integral_constant::value || is_floating_point::value + >{}; + + + /////////////////////////////////////////////////////////////////////// + // is_fundamental + // + // is_fundamental::value == true if and only if: + // is_floating_point::value == true, or + // is_integral::value == true, or + // is_void::value == true + /////////////////////////////////////////////////////////////////////// + template + struct is_fundamental : public integral_constant::value || is_integral::value || is_floating_point::value + >{}; + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/type_pod.h b/lib/eastl/include/EASTL/internal/type_pod.h new file mode 100644 index 0000000..afcf68e --- /dev/null +++ b/lib/eastl/include/EASTL/internal/type_pod.h @@ -0,0 +1,306 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/type_pod.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_TYPE_POD_H +#define EASTL_INTERNAL_TYPE_POD_H + + +#include + + +namespace eastl +{ + + + // The following properties or relations are defined here. If the given + // item is missing then it simply hasn't been implemented, at least not yet. + // is_empty + // is_pod + // has_trivial_constructor + // has_trivial_copy + // has_trivial_assign + // has_trivial_destructor + // has_trivial_relocate -- EA extension to the C++ standard proposal. + // has_nothrow_constructor + // has_nothrow_copy + // has_nothrow_assign + // has_virtual_destructor + + + + + /////////////////////////////////////////////////////////////////////// + // is_empty + // + // is_empty::value == true if and only if T is an empty class or struct. + // is_empty may only be applied to complete types. + // + // is_empty cannot be used with union types until is_union can be made to work. + /////////////////////////////////////////////////////////////////////// + template + struct is_empty_helper_t1 : public T { char m[64]; }; + struct is_empty_helper_t2 { char m[64]; }; + + // The inheritance in empty_helper_t1 will not work with non-class types + template + struct is_empty_helper : public false_type{}; + + template + struct is_empty_helper : public integral_constant) == sizeof(is_empty_helper_t2) + >{}; + + template + struct is_empty_helper2 + { + typedef typename remove_cv::type _T; + typedef is_empty_helper<_T, is_class<_T>::value> type; + }; + + template + struct is_empty : public is_empty_helper2::type {}; + + + /////////////////////////////////////////////////////////////////////// + // is_pod + // + // is_pod::value == true if and only if, for a given type T: + // - is_scalar::value == true, or + // - T is a class or struct that has no user-defined copy + // assignment operator or destructor, and T has no non-static + // data members M for which is_pod::value == false, and no + // members of reference type, or + // - T is a class or struct that has no user-defined copy assignment + // operator or destructor, and T has no non-static data members M for + // which is_pod::value == false, and no members of reference type, or + // - T is the type of an array of objects E for which is_pod::value == true + // + // is_pod may only be applied to complete types. + // + // Without some help from the compiler or user, is_pod will not report + // that a struct or class is a POD, but will correctly report that + // built-in types such as int are PODs. The user can help the compiler + // by using the EASTL_DECLARE_POD macro on a class. + /////////////////////////////////////////////////////////////////////// + template // There's not much we can do here without some compiler extension. + struct is_pod : public integral_constant::value || is_scalar::value>{}; + + template + struct is_pod : public is_pod{}; + + template + struct is_POD : public is_pod{}; + + #define EASTL_DECLARE_POD(T) namespace eastl{ template <> struct is_pod : public true_type{}; template <> struct is_pod : public true_type{}; } + + + + + /////////////////////////////////////////////////////////////////////// + // has_trivial_constructor + // + // has_trivial_constructor::value == true if and only if T is a class + // or struct that has a trivial constructor. A constructor is trivial if + // - it is implicitly defined by the compiler, and + // - is_polymorphic::value == false, and + // - T has no virtual base classes, and + // - for every direct base class of T, has_trivial_constructor::value == true, + // where B is the type of the base class, and + // - for every nonstatic data member of T that has class type or array + // of class type, has_trivial_constructor::value == true, + // where M is the type of the data member + // + // has_trivial_constructor may only be applied to complete types. + // + // Without from the compiler or user, has_trivial_constructor will not + // report that a class or struct has a trivial constructor. + // The user can use EASTL_DECLARE_TRIVIAL_CONSTRUCTOR to help the compiler. + // + // A default constructor for a class X is a constructor of class X that + // can be called without an argument. + /////////////////////////////////////////////////////////////////////// + + // With current compilers, this is all we can do. + template + struct has_trivial_constructor : public is_pod {}; + + #define EASTL_DECLARE_TRIVIAL_CONSTRUCTOR(T) namespace eastl{ template <> struct has_trivial_constructor : public true_type{}; template <> struct has_trivial_constructor : public true_type{}; } + + + + + /////////////////////////////////////////////////////////////////////// + // has_trivial_copy + // + // has_trivial_copy::value == true if and only if T is a class or + // struct that has a trivial copy constructor. A copy constructor is + // trivial if + // - it is implicitly defined by the compiler, and + // - is_polymorphic::value == false, and + // - T has no virtual base classes, and + // - for every direct base class of T, has_trivial_copy::value == true, + // where B is the type of the base class, and + // - for every nonstatic data member of T that has class type or array + // of class type, has_trivial_copy::value == true, where M is the + // type of the data member + // + // has_trivial_copy may only be applied to complete types. + // + // Another way of looking at this is: + // A copy constructor for class X is trivial if it is implicitly + // declared and if all the following are true: + // - Class X has no virtual functions (10.3) and no virtual base classes (10.1). + // - Each direct base class of X has a trivial copy constructor. + // - For all the nonstatic data members of X that are of class type + // (or array thereof), each such class type has a trivial copy constructor; + // otherwise the copy constructor is nontrivial. + // + // Without from the compiler or user, has_trivial_copy will not report + // that a class or struct has a trivial copy constructor. The user can + // use EASTL_DECLARE_TRIVIAL_COPY to help the compiler. + /////////////////////////////////////////////////////////////////////// + + template + struct has_trivial_copy : public integral_constant::value && !is_volatile::value>{}; + + #define EASTL_DECLARE_TRIVIAL_COPY(T) namespace eastl{ template <> struct has_trivial_copy : public true_type{}; template <> struct has_trivial_copy : public true_type{}; } + + + /////////////////////////////////////////////////////////////////////// + // has_trivial_assign + // + // has_trivial_assign::value == true if and only if T is a class or + // struct that has a trivial copy assignment operator. A copy assignment + // operator is trivial if: + // - it is implicitly defined by the compiler, and + // - is_polymorphic::value == false, and + // - T has no virtual base classes, and + // - for every direct base class of T, has_trivial_assign::value == true, + // where B is the type of the base class, and + // - for every nonstatic data member of T that has class type or array + // of class type, has_trivial_assign::value == true, where M is + // the type of the data member. + // + // has_trivial_assign may only be applied to complete types. + // + // Without from the compiler or user, has_trivial_assign will not + // report that a class or struct has trivial assignment. The user + // can use EASTL_DECLARE_TRIVIAL_ASSIGN to help the compiler. + /////////////////////////////////////////////////////////////////////// + + template + struct has_trivial_assign : public integral_constant::value && !is_const::value && !is_volatile::value + >{}; + + #define EASTL_DECLARE_TRIVIAL_ASSIGN(T) namespace eastl{ template <> struct has_trivial_assign : public true_type{}; template <> struct has_trivial_assign : public true_type{}; } + + + + + /////////////////////////////////////////////////////////////////////// + // has_trivial_destructor + // + // has_trivial_destructor::value == true if and only if T is a class + // or struct that has a trivial destructor. A destructor is trivial if + // - it is implicitly defined by the compiler, and + // - for every direct base class of T, has_trivial_destructor::value == true, + // where B is the type of the base class, and + // - for every nonstatic data member of T that has class type or + // array of class type, has_trivial_destructor::value == true, + // where M is the type of the data member + // + // has_trivial_destructor may only be applied to complete types. + // + // Without from the compiler or user, has_trivial_destructor will not + // report that a class or struct has a trivial destructor. + // The user can use EASTL_DECLARE_TRIVIAL_DESTRUCTOR to help the compiler. + /////////////////////////////////////////////////////////////////////// + + // With current compilers, this is all we can do. + template + struct has_trivial_destructor : public is_pod{}; + + #define EASTL_DECLARE_TRIVIAL_DESTRUCTOR(T) namespace eastl{ template <> struct has_trivial_destructor : public true_type{}; template <> struct has_trivial_destructor : public true_type{}; } + + + /////////////////////////////////////////////////////////////////////// + // has_trivial_relocate + // + // This is an EA extension to the type traits standard. + // + // A trivially relocatable object is one that can be safely memmove'd + // to uninitialized memory. construction, assignment, and destruction + // properties are not addressed by this trait. A type that has the + // is_fundamental trait would always have the has_trivial_relocate trait. + // A type that has the has_trivial_constructor, has_trivial_copy or + // has_trivial_assign traits would usally have the has_trivial_relocate + // trait, but this is not strictly guaranteed. + // + // The user can use EASTL_DECLARE_TRIVIAL_RELOCATE to help the compiler. + /////////////////////////////////////////////////////////////////////// + + // With current compilers, this is all we can do. + template + struct has_trivial_relocate : public integral_constant::value && !is_volatile::value>{}; + + #define EASTL_DECLARE_TRIVIAL_RELOCATE(T) namespace eastl{ template <> struct has_trivial_relocate : public true_type{}; template <> struct has_trivial_relocate : public true_type{}; } + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/type_properties.h b/lib/eastl/include/EASTL/internal/type_properties.h new file mode 100644 index 0000000..c07a7c0 --- /dev/null +++ b/lib/eastl/include/EASTL/internal/type_properties.h @@ -0,0 +1,283 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/type_properties.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_TYPE_PROPERTIES_H +#define EASTL_INTERNAL_TYPE_PROPERTIES_H + + +#include + + +namespace eastl +{ + + // The following properties or relations are defined here. If the given + // item is missing then it simply hasn't been implemented, at least not yet. + + /////////////////////////////////////////////////////////////////////// + // is_const + // + // is_const::value == true if and only if T has const-qualification. + // + /////////////////////////////////////////////////////////////////////// + template struct is_const_value : public false_type{}; + template struct is_const_value : public true_type{}; + template struct is_const_value : public true_type{}; + + template struct is_const : public is_const_value{}; + template struct is_const : public false_type{}; // Note here that T is const, not the reference to T. So is_const is false. See section 8.3.2p1 of the C++ standard. + + + + /////////////////////////////////////////////////////////////////////// + // is_volatile + // + // is_volatile::value == true if and only if T has volatile-qualification. + // + /////////////////////////////////////////////////////////////////////// + + template struct is_volatile_value : public false_type{}; + template struct is_volatile_value : public true_type{}; + template struct is_volatile_value : public true_type{}; + + template struct is_volatile : public is_volatile_value{}; + template struct is_volatile : public false_type{}; // Note here that T is volatile, not the reference to T. So is_const is false. See section 8.3.2p1 of the C++ standard. + + + + /////////////////////////////////////////////////////////////////////// + // is_abstract + // + // is_abstract::value == true if and only if T is a class or struct + // that has at least one pure virtual function. is_abstract may only + // be applied to complete types. + // + /////////////////////////////////////////////////////////////////////// + + // Not implemented yet. + + + + /////////////////////////////////////////////////////////////////////// + // is_signed + // + // is_signed::value == true if and only if T is one of the following types: + // [const] [volatile] char (maybe) + // [const] [volatile] signed char + // [const] [volatile] short + // [const] [volatile] int + // [const] [volatile] long + // [const] [volatile] long long + // + // Used to determine if a integral type is signed or unsigned. + // Given that there are some user-made classes which emulate integral + // types, we provide the EASTL_DECLARE_SIGNED macro to allow you to + // set a given class to be identified as a signed type. + /////////////////////////////////////////////////////////////////////// + template struct is_signed : public false_type{}; + + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + + #if (CHAR_MAX == SCHAR_MAX) + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + #endif + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + #if defined(__WCHAR_MAX__) && ((__WCHAR_MAX__ == 2147483647) || (__WCHAR_MAX__ == 32767)) // GCC defines __WCHAR_MAX__ for most platforms. + template <> struct is_signed : public true_type{}; + template <> struct is_signed : public true_type{}; + #endif + #endif + + #define EASTL_DECLARE_SIGNED(T) namespace eastl{ template <> struct is_signed : public true_type{}; template <> struct is_signed : public true_type{}; } + + + + /////////////////////////////////////////////////////////////////////// + // is_unsigned + // + // is_unsigned::value == true if and only if T is one of the following types: + // [const] [volatile] char (maybe) + // [const] [volatile] unsigned char + // [const] [volatile] unsigned short + // [const] [volatile] unsigned int + // [const] [volatile] unsigned long + // [const] [volatile] unsigned long long + // + // Used to determine if a integral type is signed or unsigned. + // Given that there are some user-made classes which emulate integral + // types, we provide the EASTL_DECLARE_UNSIGNED macro to allow you to + // set a given class to be identified as an unsigned type. + /////////////////////////////////////////////////////////////////////// + template struct is_unsigned : public false_type{}; + + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + + #if (CHAR_MAX == UCHAR_MAX) + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + #endif + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + #if defined(_MSC_VER) || (defined(__WCHAR_MAX__) && ((__WCHAR_MAX__ == 4294967295U) || (__WCHAR_MAX__ == 65535))) // GCC defines __WCHAR_MAX__ for most platforms. + template <> struct is_unsigned : public true_type{}; + template <> struct is_unsigned : public true_type{}; + #endif + #endif + + #define EASTL_DECLARE_UNSIGNED(T) namespace eastl{ template <> struct is_unsigned : public true_type{}; template <> struct is_unsigned : public true_type{}; } + + + + /////////////////////////////////////////////////////////////////////// + // alignment_of + // + // alignment_of::value is an integral value representing, in bytes, + // the memory alignment of objects of type T. + // + // alignment_of may only be applied to complete types. + // + /////////////////////////////////////////////////////////////////////// + template + struct alignment_of_value{ static const size_t value = EASTL_ALIGN_OF(T); }; + + template + struct alignment_of : public integral_constant::value>{}; + + + + /////////////////////////////////////////////////////////////////////// + // is_aligned + // + // Defined as true if the type has alignment requirements greater + // than default alignment, which is taken to be 8. This allows for + // doing specialized object allocation and placement for such types. + /////////////////////////////////////////////////////////////////////// + template + struct is_aligned_value{ static const bool value = (EASTL_ALIGN_OF(T) > 8); }; + + template + struct is_aligned : public integral_constant::value>{}; + + + + /////////////////////////////////////////////////////////////////////// + // rank + // + // rank::value is an integral value representing the number of + // dimensions possessed by an array type. For example, given a + // multi-dimensional array type T[M][N], std::tr1::rank::value == 2. + // For a given non-array type T, std::tr1::rank::value == 0. + // + /////////////////////////////////////////////////////////////////////// + + // Not implemented yet. + + + + /////////////////////////////////////////////////////////////////////// + // extent + // + // extent::value is an integral type representing the number of + // elements in the Ith dimension of array type T. + // + // For a given array type T[N], std::tr1::extent::value == N. + // For a given multi-dimensional array type T[M][N], std::tr1::extent::value == N. + // For a given multi-dimensional array type T[M][N], std::tr1::extent::value == M. + // For a given array type T and a given dimension I where I >= rank::value, std::tr1::extent::value == 0. + // For a given array type of unknown extent T[], std::tr1::extent::value == 0. + // For a given non-array type T and an arbitrary dimension I, std::tr1::extent::value == 0. + // + /////////////////////////////////////////////////////////////////////// + + // Not implemented yet. + + + + /////////////////////////////////////////////////////////////////////// + // is_base_of + // + // Given two (possibly identical) types Base and Derived, is_base_of::value == true + // if and only if Base is a direct or indirect base class of Derived, + // or Base and Derived are the same type. + // + // is_base_of may only be applied to complete types. + // + /////////////////////////////////////////////////////////////////////// + + // Not implemented yet. + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/internal/type_transformations.h b/lib/eastl/include/EASTL/internal/type_transformations.h new file mode 100644 index 0000000..f086c0b --- /dev/null +++ b/lib/eastl/include/EASTL/internal/type_transformations.h @@ -0,0 +1,244 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/internal/type_transformations.h +// Written and maintained by Paul Pedriana - 2005 +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_INTERNAL_TYPE_TRANFORMATIONS_H +#define EASTL_INTERNAL_TYPE_TRANFORMATIONS_H + + +namespace eastl +{ + + + // The following transformations are defined here. If the given item + // is missing then it simply hasn't been implemented, at least not yet. + // add_unsigned + // add_signed + // remove_const + // remove_volatile + // remove_cv + // add_const + // add_volatile + // add_cv + // remove_reference + // add_reference + // remove_extent + // remove_all_extents + // remove_pointer + // add_pointer + // aligned_storage + + + /////////////////////////////////////////////////////////////////////// + // add_signed + // + // Adds signed-ness to the given type. + // Modifies only integral values; has no effect on others. + // add_signed::type is int + // add_signed::type is int + // + /////////////////////////////////////////////////////////////////////// + + template + struct add_signed + { typedef T type; }; + + template<> + struct add_signed + { typedef signed char type; }; + + #if (defined(CHAR_MAX) && defined(UCHAR_MAX) && (CHAR_MAX == UCHAR_MAX)) // If char is unsigned (which is usually not the case)... + template<> + struct add_signed + { typedef signed char type; }; + #endif + + template<> + struct add_signed + { typedef short type; }; + + template<> + struct add_signed + { typedef int type; }; + + template<> + struct add_signed + { typedef long type; }; + + template<> + struct add_signed + { typedef long long type; }; + + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + #if (defined(__WCHAR_MAX__) && (__WCHAR_MAX__ == 4294967295U)) // If wchar_t is a 32 bit unsigned value... + template<> + struct add_signed + { typedef int32_t type; }; + #elif (defined(__WCHAR_MAX__) && (__WCHAR_MAX__ == 65535)) // If wchar_t is a 16 bit unsigned value... + template<> + struct add_signed + { typedef int16_t type; }; + #endif + #endif + + + + /////////////////////////////////////////////////////////////////////// + // add_unsigned + // + // Adds unsigned-ness to the given type. + // Modifies only integral values; has no effect on others. + // add_unsigned::type is unsigned int + // add_unsigned::type is unsigned int + // + /////////////////////////////////////////////////////////////////////// + + template + struct add_unsigned + { typedef T type; }; + + template<> + struct add_unsigned + { typedef unsigned char type; }; + + #if (defined(CHAR_MAX) && defined(SCHAR_MAX) && (CHAR_MAX == SCHAR_MAX)) // If char is signed (which is usually so)... + template<> + struct add_unsigned + { typedef unsigned char type; }; + #endif + + template<> + struct add_unsigned + { typedef unsigned short type; }; + + template<> + struct add_unsigned + { typedef unsigned int type; }; + + template<> + struct add_unsigned + { typedef unsigned long type; }; + + template<> + struct add_unsigned + { typedef unsigned long long type; }; + + #ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type... + #if (defined(__WCHAR_MAX__) && (__WCHAR_MAX__ == 2147483647)) // If wchar_t is a 32 bit signed value... + template<> + struct add_unsigned + { typedef uint32_t type; }; + #elif (defined(__WCHAR_MAX__) && (__WCHAR_MAX__ == 32767)) // If wchar_t is a 16 bit signed value... + template<> + struct add_unsigned + { typedef uint16_t type; }; + #endif + #endif + + /////////////////////////////////////////////////////////////////////// + // remove_cv + // + // Remove const and volatile from a type. + // + // The remove_cv transformation trait removes top-level const and/or volatile + // qualification (if any) from the type to which it is applied. For a given type T, + // remove_cv::type is equivalent to T. For example, + // remove_cv::type is equivalent to char*, while remove_cv::type + // is equivalent to const char*. In the latter case, the const qualifier modifies + // char, not *, and is therefore not at the top level. + // + /////////////////////////////////////////////////////////////////////// + template struct remove_cv_imp{}; + template struct remove_cv_imp { typedef T unqualified_type; }; + template struct remove_cv_imp { typedef T unqualified_type; }; + template struct remove_cv_imp { typedef T unqualified_type; }; + template struct remove_cv_imp { typedef T unqualified_type; }; + + template struct remove_cv{ typedef typename remove_cv_imp::unqualified_type type; }; + template struct remove_cv{ typedef T& type; }; // References are automatically not const nor volatile. See section 8.3.2p1 of the C++ standard. + + template struct remove_cv { typedef T type[N]; }; + template struct remove_cv { typedef T type[N]; }; + template struct remove_cv{ typedef T type[N]; }; + + + + /////////////////////////////////////////////////////////////////////// + // add_reference + // + // Add reference to a type. + // + // The add_reference transformation trait adds a level of indirection + // by reference to the type to which it is applied. For a given type T, + // add_reference::type is equivalent to T& if is_reference::value == false, + // and T otherwise. + // + /////////////////////////////////////////////////////////////////////// + template + struct add_reference_impl{ typedef T& type; }; + + template + struct add_reference_impl{ typedef T& type; }; + + template <> + struct add_reference_impl{ typedef void type; }; + + template + struct add_reference { typedef typename add_reference_impl::type type; }; + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/iterator.h b/lib/eastl/include/EASTL/iterator.h new file mode 100644 index 0000000..09ba9e6 --- /dev/null +++ b/lib/eastl/include/EASTL/iterator.h @@ -0,0 +1,621 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/iterator.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_ITERATOR_H +#define EASTL_ITERATOR_H + + +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) +#endif + +#include + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +// If the user has specified that we use std iterator +// categories instead of EASTL iterator categories, +// then #include . +#if EASTL_STD_ITERATOR_CATEGORY_ENABLED + #ifdef _MSC_VER + #pragma warning(push, 0) + #endif + #include + #ifdef _MSC_VER + #pragma warning(pop) + #endif +#endif + + +#ifdef _MSC_VER + #pragma warning(push) // VC++ generates a bogus warning that you cannot code away. + #pragma warning(disable: 4619) // There is no warning number 'number'. + #pragma warning(disable: 4217) // Member template functions cannot be used for copy-assignment or copy-construction. +#elif defined(__SNC__) + #pragma control %push diag + #pragma diag_suppress=187 // Pointless comparison of unsigned integer with zero +#endif + + +namespace eastl +{ + /// iterator_status_flag + /// + /// Defines the validity status of an iterator. This is primarily used for + /// iterator validation in debug builds. These are implemented as OR-able + /// flags (as opposed to mutually exclusive values) in order to deal with + /// the nature of iterator status. In particular, an iterator may be valid + /// but not dereferencable, as in the case with an iterator to container end(). + /// An iterator may be valid but also dereferencable, as in the case with an + /// iterator to container begin(). + /// + enum iterator_status_flag + { + isf_none = 0x00, /// This is called none and not called invalid because it is not strictly the opposite of invalid. + isf_valid = 0x01, /// The iterator is valid, which means it is in the range of [begin, end]. + isf_current = 0x02, /// The iterator is valid and points to the same element it did when created. For example, if an iterator points to vector::begin() but an element is inserted at the front, the iterator is valid but not current. Modification of elements in place do not make iterators non-current. + isf_can_dereference = 0x04 /// The iterator is dereferencable, which means it is in the range of [begin, end). It may or may not be current. + }; + + + + // The following declarations are taken directly from the C++ standard document. + // input_iterator_tag, etc. + // iterator + // iterator_traits + // reverse_iterator + + // Iterator categories + // Every iterator is defined as belonging to one of the iterator categories that + // we define here. These categories come directly from the C++ standard. + #if !EASTL_STD_ITERATOR_CATEGORY_ENABLED // If we are to use our own iterator category definitions... + struct input_iterator_tag { }; + struct output_iterator_tag { }; + struct forward_iterator_tag : public input_iterator_tag { }; + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; + struct contiguous_iterator_tag : public random_access_iterator_tag { }; // Extension to the C++ standard. Contiguous ranges are more than random access, they are physically contiguous. + #endif + + + // struct iterator + template + struct iterator + { + typedef Category iterator_category; + typedef T value_type; + typedef Distance difference_type; + typedef Pointer pointer; + typedef Reference reference; + }; + + + // struct iterator_traits + template + struct iterator_traits + { + typedef typename Iterator::iterator_category iterator_category; + typedef typename Iterator::value_type value_type; + typedef typename Iterator::difference_type difference_type; + typedef typename Iterator::pointer pointer; + typedef typename Iterator::reference reference; + }; + + template + struct iterator_traits + { + typedef EASTL_ITC_NS::random_access_iterator_tag iterator_category; // To consider: Change this to contiguous_iterator_tag for the case that + typedef T value_type; // EASTL_ITC_NS is "eastl" instead of "std". + typedef ptrdiff_t difference_type; + typedef T* pointer; + typedef T& reference; + }; + + template + struct iterator_traits + { + typedef EASTL_ITC_NS::random_access_iterator_tag iterator_category; + typedef T value_type; + typedef ptrdiff_t difference_type; + typedef const T* pointer; + typedef const T& reference; + }; + + + + + + /// reverse_iterator + /// + /// From the C++ standard: + /// Bidirectional and random access iterators have corresponding reverse + /// iterator adaptors that iterate through the data structure in the + /// opposite direction. They have the same signatures as the corresponding + /// iterators. The fundamental relation between a reverse iterator and its + /// corresponding iterator i is established by the identity: + /// &*(reverse_iterator(i)) == &*(i - 1). + /// This mapping is dictated by the fact that while there is always a pointer + /// past the end of an array, there might not be a valid pointer before the + /// beginning of an array. + /// + template + class reverse_iterator : public iterator::iterator_category, + typename eastl::iterator_traits::value_type, + typename eastl::iterator_traits::difference_type, + typename eastl::iterator_traits::pointer, + typename eastl::iterator_traits::reference> + { + public: + typedef Iterator iterator_type; + typedef typename eastl::iterator_traits::pointer pointer; + typedef typename eastl::iterator_traits::reference reference; + typedef typename eastl::iterator_traits::difference_type difference_type; + + protected: + Iterator mIterator; + + public: + reverse_iterator() // It's important that we construct mIterator, because if Iterator + : mIterator() { } // is a pointer, there's a difference between doing it and not. + + explicit reverse_iterator(iterator_type i) + : mIterator(i) { } + + reverse_iterator(const reverse_iterator& ri) + : mIterator(ri.mIterator) { } + + template + reverse_iterator(const reverse_iterator& ri) + : mIterator(ri.base()) { } + + // This operator= isn't in the standard, but the the C++ + // library working group has tentatively approved it, as it + // allows const and non-const reverse_iterators to interoperate. + template + reverse_iterator& operator=(const reverse_iterator& ri) + { mIterator = ri.base(); return *this; } + + iterator_type base() const + { return mIterator; } + + reference operator*() const + { + iterator_type i(mIterator); + return *--i; + } + + pointer operator->() const + { return &(operator*()); } + + reverse_iterator& operator++() + { --mIterator; return *this; } + + reverse_iterator operator++(int) + { + reverse_iterator ri(*this); + --mIterator; + return ri; + } + + reverse_iterator& operator--() + { ++mIterator; return *this; } + + reverse_iterator operator--(int) + { + reverse_iterator ri(*this); + ++mIterator; + return ri; + } + + reverse_iterator operator+(difference_type n) const + { return reverse_iterator(mIterator - n); } + + reverse_iterator& operator+=(difference_type n) + { mIterator -= n; return *this; } + + reverse_iterator operator-(difference_type n) const + { return reverse_iterator(mIterator + n); } + + reverse_iterator& operator-=(difference_type n) + { mIterator += n; return *this; } + + reference operator[](difference_type n) const + { return mIterator[-n - 1]; } + }; + + + // The C++ library working group has tentatively approved the usage of two + // template parameters (Iterator1 and Iterator2) in order to allow reverse_iterators + // and const_reverse iterators to be comparable. This is a similar issue to the + // C++ defect report #179 regarding comparison of container iterators and const_iterators. + template + inline bool + operator==(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() == b.base(); } + + + template + inline bool + operator<(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() > b.base(); } + + + template + inline bool + operator!=(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() != b.base(); } + + + template + inline bool + operator>(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() < b.base(); } + + + template + inline bool + operator<=(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() >= b.base(); } + + + template + inline bool + operator>=(const reverse_iterator& a, const reverse_iterator& b) + { return a.base() <= b.base(); } + + + template + inline typename reverse_iterator::difference_type + operator-(const reverse_iterator& a, const reverse_iterator& b) + { return b.base() - a.base(); } + + + template + inline reverse_iterator + operator+(typename reverse_iterator::difference_type n, const reverse_iterator& a) + { return reverse_iterator(a.base() - n); } + + + + + + + + /// back_insert_iterator + /// + /// A back_insert_iterator is simply a class that acts like an iterator but when you + /// assign a value to it, it calls push_back on the container with the value. + /// + template + class back_insert_iterator : public iterator + { + public: + typedef Container container_type; + typedef typename Container::const_reference const_reference; + + protected: + Container& container; + + public: + explicit back_insert_iterator(Container& x) + : container(x) { } + + back_insert_iterator& operator=(const_reference value) + { container.push_back(value); return *this; } + + back_insert_iterator& operator*() + { return *this; } + + back_insert_iterator& operator++() + { return *this; } // This is by design. + + back_insert_iterator operator++(int) + { return *this; } // This is by design. + }; + + + /// back_inserter + /// + /// Creates an instance of a back_insert_iterator. + /// + template + inline back_insert_iterator + back_inserter(Container& x) + { return back_insert_iterator(x); } + + + + + /// front_insert_iterator + /// + /// A front_insert_iterator is simply a class that acts like an iterator but when you + /// assign a value to it, it calls push_front on the container with the value. + /// + template + class front_insert_iterator : public iterator + { + public: + typedef Container container_type; + typedef typename Container::const_reference const_reference; + + protected: + Container& container; + + public: + explicit front_insert_iterator(Container& x) + : container(x) { } + + front_insert_iterator& operator=(const_reference value) + { container.push_front(value); return *this; } + + front_insert_iterator& operator*() + { return *this; } + + front_insert_iterator& operator++() + { return *this; } // This is by design. + + front_insert_iterator operator++(int) + { return *this; } // This is by design. + }; + + + /// front_inserter + /// + /// Creates an instance of a front_insert_iterator. + /// + template + inline front_insert_iterator + front_inserter(Container& x) + { return front_insert_iterator(x); } + + + + + /// insert_iterator + /// + /// An insert_iterator is like an iterator except that when you assign a value to it, + /// the insert_iterator inserts the value into the container and increments the iterator. + /// + /// insert_iterator is an iterator adaptor that functions as an OutputIterator: + /// assignment through an insert_iterator inserts an object into a container. + /// Specifically, if ii is an insert_iterator, then ii keeps track of a container c and + /// an insertion point p; the expression *ii = x performs the insertion c.insert(p, x). + /// + /// If you assign through an insert_iterator several times, then you will be inserting + /// several elements into the underlying container. In the case of a sequence, they will + /// appear at a particular location in the underlying sequence, in the order in which + /// they were inserted: one of the arguments to insert_iterator's constructor is an + /// iterator p, and the new range will be inserted immediately before p. + /// + template + class insert_iterator : public iterator + { + public: + typedef Container container_type; + typedef typename Container::iterator iterator_type; + typedef typename Container::const_reference const_reference; + + protected: + Container& container; + iterator_type it; + + public: + // This assignment operator is defined more to stop compiler warnings (e.g. VC++ C4512) + // than to be useful. However, it does an insert_iterator to be assigned to another + // insert iterator provided that they point to the same container. + insert_iterator& operator=(const insert_iterator& x) + { + EASTL_ASSERT(&x.container == &container); + it = x.it; + return *this; + } + + insert_iterator(Container& x, iterator_type itNew) + : container(x), it(itNew) {} + + insert_iterator& operator=(const_reference value) + { + it = container.insert(it, value); + ++it; + return *this; + } + + insert_iterator& operator*() + { return *this; } + + insert_iterator& operator++() + { return *this; } // This is by design. + + insert_iterator& operator++(int) + { return *this; } // This is by design. + + }; // insert_iterator + + + /// inserter + /// + /// Creates an instance of an insert_iterator. + /// + template + inline eastl::insert_iterator + inserter(Container& x, Iterator i) + { + typedef typename Container::iterator iterator; + return eastl::insert_iterator(x, iterator(i)); + } + + + + + ////////////////////////////////////////////////////////////////////////////////// + /// distance + /// + /// Implements the distance() function. There are two versions, one for + /// random access iterators (e.g. with vector) and one for regular input + /// iterators (e.g. with list). The former is more efficient. + /// + template + inline typename eastl::iterator_traits::difference_type + distance_impl(InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag) + { + typename eastl::iterator_traits::difference_type n = 0; + + while(first != last) + { + ++first; + ++n; + } + return n; + } + + template + inline typename eastl::iterator_traits::difference_type + distance_impl(RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag) + { + return last - first; + } + + // Special version defined so that std C++ iterators can be recognized by + // this function. Unfortunately, this function treats all foreign iterators + // as InputIterators and thus can seriously hamper performance in the case + // of large ranges of bidirectional_iterator_tag iterators. + //template + //inline typename eastl::iterator_traits::difference_type + //distance_impl(InputIterator first, InputIterator last, ...) + //{ + // typename eastl::iterator_traits::difference_type n = 0; + // + // while(first != last) + // { + // ++first; + // ++n; + // } + // return n; + //} + + template + inline typename eastl::iterator_traits::difference_type + distance(InputIterator first, InputIterator last) + { + typedef typename eastl::iterator_traits::iterator_category IC; + + return eastl::distance_impl(first, last, IC()); + } + + + + + ////////////////////////////////////////////////////////////////////////////////// + /// advance + /// + /// Implements the advance() function. There are three versions, one for + /// random access iterators (e.g. with vector), one for bidirectional + /// iterators (list) and one for regular input iterators (e.g. with slist). + /// + template + inline void + advance_impl(InputIterator& i, Distance n, EASTL_ITC_NS::input_iterator_tag) + { + while(n--) + ++i; + } + + template + inline void + advance_impl(BidirectionalIterator& i, Distance n, EASTL_ITC_NS::bidirectional_iterator_tag) + { + if(n > 0) + { + while(n--) + ++i; + } + else + { + while(n++) + --i; + } + } + + template + inline void + advance_impl(RandomAccessIterator& i, Distance n, EASTL_ITC_NS::random_access_iterator_tag) + { + i += n; + } + + // Special version defined so that std C++ iterators can be recognized by + // this function. Unfortunately, this function treats all foreign iterators + // as InputIterators and thus can seriously hamper performance in the case + // of large ranges of bidirectional_iterator_tag iterators. + //template + //inline void + //advance_impl(InputIterator& i, Distance n, ...) + //{ + // while(n--) + // ++i; + //} + + template + inline void + advance(InputIterator& i, Distance n) + { + typedef typename eastl::iterator_traits::iterator_category IC; + + eastl::advance_impl(i, n, IC()); + } + + +} // namespace eastl + + +#if defined(_MSC_VER) + #pragma warning(pop) +#elif defined(__SNC__) + #pragma control %pop diag +#endif + + +#endif // Header include guard + + + + + diff --git a/lib/eastl/include/EASTL/list.h b/lib/eastl/include/EASTL/list.h new file mode 100644 index 0000000..440d686 --- /dev/null +++ b/lib/eastl/include/EASTL/list.h @@ -0,0 +1,1863 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/list.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a doubly-linked list, much like the C++ std::list class. +// The primary distinctions between this list and std::list are: +// - list doesn't implement some of the less-frequently used functions +// of std::list. Any required functions can be added at a later time. +// - list has a couple extension functions that increase performance. +// - list can contain objects with alignment requirements. std::list cannot +// do so without a bit of tedious non-portable effort. +// - list has optimizations that don't exist in the STL implementations +// supplied by library vendors for our targeted platforms. +// - list supports debug memory naming natively. +// - list::size() by default is not a constant time function, like the list::size +// in some std implementations such as STLPort and SGI STL but unlike the +// list in Dinkumware and Metrowerks. The EASTL_LIST_SIZE_CACHE option can change this. +// - list provides a guaranteed portable node definition that allows users +// to write custom fixed size node allocators that are portable. +// - list is easier to read, debug, and visualize. +// - list is savvy to an environment that doesn't have exception handling, +// as is sometimes the case with console or embedded environments. +// - list has less deeply nested function calls and allows the user to +// enable forced inlining in debug builds in order to reduce bloat. +// - list doesn't keep a member size variable. This means that list is +// smaller than std::list (depends on std::list) and that for most operations +// it is faster than std::list. However, the list::size function is slower. +// - list::size_type is defined as eastl_size_t instead of size_t in order to +// save memory and run faster on 64 bit systems. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_LIST_H +#define EASTL_LIST_H + + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) + #include + #include + #pragma warning(pop) +#else + #include + #include +#endif + +#ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc + #pragma warning(disable: 4345) // Behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized +#endif + + +namespace eastl +{ + + /// EASTL_LIST_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_LIST_DEFAULT_NAME + #define EASTL_LIST_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " list" // Unless the user overrides something, this is "EASTL list". + #endif + + + /// EASTL_LIST_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_LIST_DEFAULT_ALLOCATOR + #define EASTL_LIST_DEFAULT_ALLOCATOR allocator_type(EASTL_LIST_DEFAULT_NAME) + #endif + + + + /// ListNodeBase + /// + /// We define a ListNodeBase separately from ListNode (below), because it allows + /// us to have non-templated operations such as insert, remove (below), and it + /// makes it so that the list anchor node doesn't carry a T with it, which would + /// waste space and possibly lead to surprising the user due to extra Ts existing + /// that the user didn't explicitly create. The downside to all of this is that + /// it makes debug viewing of a list harder, given that the node pointers are of + /// type ListNodeBase and not ListNode. However, see ListNodeBaseProxy below. + /// + struct ListNodeBase + { + ListNodeBase* mpNext; + ListNodeBase* mpPrev; + + void insert(ListNodeBase* pNext); + void remove(); + void splice(ListNodeBase* pFirst, ListNodeBase* pLast); + void reverse(); + static void swap(ListNodeBase& a, ListNodeBase& b); + } EASTL_LIST_PROXY_MAY_ALIAS; + + + #if EASTL_LIST_PROXY_ENABLED + + /// ListNodeBaseProxy + /// + /// In debug builds, we define ListNodeBaseProxy to be the same thing as + /// ListNodeBase, except it is templated on the parent ListNode class. + /// We do this because we want users in debug builds to be able to easily + /// view the list's contents in a debugger GUI. We do this only in a debug + /// build for the reasons described above: that ListNodeBase needs to be + /// as efficient as possible and not cause code bloat or extra function + /// calls (inlined or not). + /// + /// ListNodeBaseProxy *must* be separate from its parent class ListNode + /// because the list class must have a member node which contains no T value. + /// It is thus incorrect for us to have one single ListNode class which + /// has mpNext, mpPrev, and mValue. So we do a recursive template trick in + /// the definition and use of SListNodeBaseProxy. + /// + template + struct ListNodeBaseProxy + { + LN* mpNext; + LN* mpPrev; + }; + + template + struct ListNode : public ListNodeBaseProxy< ListNode > + { + T mValue; + }; + + #else + + template + struct ListNode : public ListNodeBase + { + T mValue; + }; + + #endif + + + + + /// ListIterator + /// + template + struct ListIterator + { + typedef ListIterator this_type; + typedef ListIterator iterator; + typedef ListIterator const_iterator; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef ListNode node_type; + typedef Pointer pointer; + typedef Reference reference; + typedef EASTL_ITC_NS::bidirectional_iterator_tag iterator_category; + + public: + node_type* mpNode; + + public: + ListIterator(); + ListIterator(const ListNodeBase* pNode); + ListIterator(const iterator& x); + + reference operator*() const; + pointer operator->() const; + + this_type& operator++(); + this_type operator++(int); + + this_type& operator--(); + this_type operator--(int); + + }; // ListIterator + + + + + /// ListBase + /// + /// See VectorBase (class vector) for an explanation of why we + /// create this separate base class. + /// + template + class ListBase + { + public: + typedef T value_type; + typedef Allocator allocator_type; + typedef ListNode node_type; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef ptrdiff_t difference_type; + #if EASTL_LIST_PROXY_ENABLED + typedef ListNodeBaseProxy< ListNode > base_node_type; + #else + typedef ListNodeBase base_node_type; // We use ListNodeBase instead of ListNode because we don't want to create a T. + #endif + + enum + { + kAlignment = EASTL_ALIGN_OF(T), + kAlignmentOffset = 0 // offsetof(node_type, mValue); + }; + + protected: + base_node_type mNode; + #if EASTL_LIST_SIZE_CACHE + size_type mSize; + #endif + allocator_type mAllocator; // To do: Use base class optimization to make this go away. + + public: + allocator_type& get_allocator(); + void set_allocator(const allocator_type& allocator); + + protected: + ListBase(); + ListBase(const allocator_type& a); + ~ListBase(); + + node_type* DoAllocateNode(); + void DoFreeNode(node_type* pNode); + + void DoInit(); + void DoClear(); + + }; // ListBase + + + + + /// list + /// + /// -- size() is O(n) -- + /// Note that as of this writing, list::size() is an O(n) operation. That is, getting the size + /// of the list is not a fast operation, as it requires traversing the list and counting the nodes. + /// We could make list::size() be fast by having a member mSize variable. There are reasons for + /// having such functionality and reasons for not having such functionality. We currently choose + /// to not have a member mSize variable as it would add four bytes to the class, add a tiny amount + /// of processing to functions such as insert and erase, and would only serve to improve the size + /// function, but no others. The alternative argument is that the C++ standard states that std::list + /// should be an O(1) operation (i.e. have a member size variable), most C++ standard library list + /// implementations do so, the size is but an integer which is quick to update, and many users + /// expect to have a fast size function. The EASTL_LIST_SIZE_CACHE option changes this. + /// To consider: Make size caching an optional template parameter. + /// + /// Pool allocation + /// If you want to make a custom memory pool for a list container, your pool + /// needs to contain items of type list::node_type. So if you have a memory + /// pool that has a constructor that takes the size of pool items and the + /// count of pool items, you would do this (assuming that MemoryPool implements + /// the Allocator interface): + /// typedef list WidgetList; // Delare your WidgetList type. + /// MemoryPool myPool(sizeof(WidgetList::node_type), 100); // Make a pool of 100 Widget nodes. + /// WidgetList myList(&myPool); // Create a list that uses the pool. + /// + template + class list : public ListBase + { + typedef ListBase base_type; + typedef list this_type; + + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef ListIterator iterator; + typedef ListIterator const_iterator; + typedef eastl::reverse_iterator reverse_iterator; + typedef eastl::reverse_iterator const_reverse_iterator; + typedef typename base_type::size_type size_type; + typedef typename base_type::difference_type difference_type; + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::base_node_type base_node_type; + + using base_type::mNode; + using base_type::mAllocator; + using base_type::DoAllocateNode; + using base_type::DoFreeNode; + using base_type::DoClear; + using base_type::DoInit; + using base_type::get_allocator; + #if EASTL_LIST_SIZE_CACHE + using base_type::mSize; + #endif + + public: + list(); + list(const allocator_type& allocator); + explicit list(size_type n, const allocator_type& allocator = EASTL_LIST_DEFAULT_ALLOCATOR); + list(size_type n, const value_type& value, const allocator_type& allocator = EASTL_LIST_DEFAULT_ALLOCATOR); + list(const this_type& x); + + template + list(InputIterator first, InputIterator last); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg. + + this_type& operator=(const this_type& x); + void swap(this_type& x); + + void assign(size_type n, const value_type& value); + + template // It turns out that the C++ std::list specifies a two argument + void assign(InputIterator first, InputIterator last); // version of assign that takes (int size, int value). These are not + // iterators, so we need to do a template compiler trick to do the right thing. + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; + reverse_iterator rend(); + const_reverse_iterator rend() const; + + bool empty() const; + size_type size() const; + + void resize(size_type n, const value_type& value); + void resize(size_type n); + + reference front(); + const_reference front() const; + + reference back(); + const_reference back() const; + + void push_front(const value_type& value); + reference push_front(); + void* push_front_uninitialized(); + + void push_back(const value_type& value); + reference push_back(); + void* push_back_uninitialized(); + + void pop_front(); + void pop_back(); + + iterator insert(iterator position); + iterator insert(iterator position, const value_type& value); + + void insert(iterator position, size_type n, const value_type& value); + + template + void insert(iterator position, InputIterator first, InputIterator last); + + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + + void clear(); + void reset(); + + void remove(const T& x); + + template + void remove_if(Predicate); + + void reverse(); + + void splice(iterator position, this_type& x); + void splice(iterator position, this_type& x, iterator i); + void splice(iterator position, this_type& x, iterator first, iterator last); + + public: + // Sorting functionality + // This is independent of the global sort algorithms, as lists are + // linked nodes and can be sorted more efficiently by moving nodes + // around in ways that global sort algorithms aren't privy to. + + void merge(this_type& x); + + template + void merge(this_type& x, Compare compare); + + void unique(); + + template + void unique(BinaryPredicate); + + void sort(); + + template + void sort(Compare compare); + + public: + bool validate() const; + int validate_iterator(const_iterator i) const; + + protected: + node_type* DoCreateNode(); + node_type* DoCreateNode(const value_type& value); + + template + void DoAssign(Integer n, Integer value, true_type); + + template + void DoAssign(InputIterator first, InputIterator last, false_type); + + void DoAssignValues(size_type n, const value_type& value); + + template + void DoInsert(ListNodeBase* pNode, Integer n, Integer value, true_type); + + template + void DoInsert(ListNodeBase* pNode, InputIterator first, InputIterator last, false_type); + + void DoInsertValues(ListNodeBase* pNode, size_type n, const value_type& value); + + void DoInsertValue(ListNodeBase* pNode, const value_type& value); + + void DoErase(ListNodeBase* pNode); + + }; // class list + + + + + + /////////////////////////////////////////////////////////////////////// + // ListNodeBase + /////////////////////////////////////////////////////////////////////// + + inline void ListNodeBase::swap(ListNodeBase& a, ListNodeBase& b) + { + const ListNodeBase temp(a); + a = b; + b = temp; + + if(a.mpNext == &b) + a.mpNext = a.mpPrev = &a; + else + a.mpNext->mpPrev = a.mpPrev->mpNext = &a; + + if(b.mpNext == &a) + b.mpNext = b.mpPrev = &b; + else + b.mpNext->mpPrev = b.mpPrev->mpNext = &b; + } + + + inline void ListNodeBase::splice(ListNodeBase* first, ListNodeBase* last) + { + // We assume that [first, last] are not within our list. + last->mpPrev->mpNext = this; + first->mpPrev->mpNext = last; + this->mpPrev->mpNext = first; + + ListNodeBase* const pTemp = this->mpPrev; + this->mpPrev = last->mpPrev; + last->mpPrev = first->mpPrev; + first->mpPrev = pTemp; + } + + + inline void ListNodeBase::reverse() + { + ListNodeBase* pNode = this; + do + { + ListNodeBase* const pTemp = pNode->mpNext; + pNode->mpNext = pNode->mpPrev; + pNode->mpPrev = pTemp; + pNode = pNode->mpPrev; + } + while(pNode != this); + } + + + inline void ListNodeBase::insert(ListNodeBase* pNext) + { + mpNext = pNext; + mpPrev = pNext->mpPrev; + pNext->mpPrev->mpNext = this; + pNext->mpPrev = this; + } + + + inline void ListNodeBase::remove() + { + mpPrev->mpNext = mpNext; + mpNext->mpPrev = mpPrev; + } + + + + + /////////////////////////////////////////////////////////////////////// + // ListIterator + /////////////////////////////////////////////////////////////////////// + + template + inline ListIterator::ListIterator() + : mpNode() // To consider: Do we really need to intialize mpNode? + { + // Empty + } + + + template + inline ListIterator::ListIterator(const ListNodeBase* pNode) + : mpNode(static_cast((ListNode*)const_cast(pNode))) // All this casting is in the name of making runtime debugging much easier on the user. + { + // Empty + } + + + template + inline ListIterator::ListIterator(const iterator& x) + : mpNode(const_cast(x.mpNode)) + { + // Empty + } + + + template + inline typename ListIterator::reference + ListIterator::operator*() const + { + return mpNode->mValue; + } + + + template + inline typename ListIterator::pointer + ListIterator::operator->() const + { + return &mpNode->mValue; + } + + + template + inline typename ListIterator::this_type& + ListIterator::operator++() + { + mpNode = static_cast(mpNode->mpNext); + return *this; + } + + + template + inline typename ListIterator::this_type + ListIterator::operator++(int) + { + this_type temp(*this); + mpNode = static_cast(mpNode->mpNext); + return temp; + } + + + template + inline typename ListIterator::this_type& + ListIterator::operator--() + { + mpNode = static_cast(mpNode->mpPrev); + return *this; + } + + + template + inline typename ListIterator::this_type + ListIterator::operator--(int) + { + this_type temp(*this); + mpNode = static_cast(mpNode->mpPrev); + return temp; + } + + + // The C++ defect report #179 requires that we support comparisons between const and non-const iterators. + // Thus we provide additional template paremeters here to support this. The defect report does not + // require us to support comparisons between reverse_iterators and const_reverse_iterators. + template + inline bool operator==(const ListIterator& a, + const ListIterator& b) + { + return a.mpNode == b.mpNode; + } + + + template + inline bool operator!=(const ListIterator& a, + const ListIterator& b) + { + return a.mpNode != b.mpNode; + } + + + // We provide a version of operator!= for the case where the iterators are of the + // same type. This helps prevent ambiguity errors in the presence of rel_ops. + template + inline bool operator!=(const ListIterator& a, + const ListIterator& b) + { + return a.mpNode != b.mpNode; + } + + + + /////////////////////////////////////////////////////////////////////// + // ListBase + /////////////////////////////////////////////////////////////////////// + + template + inline ListBase::ListBase() + : mNode(), + #if EASTL_LIST_SIZE_CACHE + mSize(0), + #endif + mAllocator(EASTL_LIST_DEFAULT_NAME) + { + DoInit(); + } + + template + inline ListBase::ListBase(const allocator_type& allocator) + : mNode(), + #if EASTL_LIST_SIZE_CACHE + mSize(0), + #endif + mAllocator(allocator) + { + DoInit(); + } + + + template + inline ListBase::~ListBase() + { + DoClear(); + } + + + template + typename ListBase::allocator_type& + ListBase::get_allocator() + { + return mAllocator; + } + + + template + inline void ListBase::set_allocator(const allocator_type& allocator) + { + mAllocator = allocator; + } + + + template + inline typename ListBase::node_type* + ListBase::DoAllocateNode() + { + return (node_type*)allocate_memory(mAllocator, sizeof(node_type), kAlignment, kAlignmentOffset); + } + + + template + inline void ListBase::DoFreeNode(node_type* p) + { + EASTLFree(mAllocator, p, sizeof(node_type)); + } + + + template + inline void ListBase::DoInit() + { + mNode.mpNext = (ListNode*)&mNode; + mNode.mpPrev = (ListNode*)&mNode; + } + + + template + inline void ListBase::DoClear() + { + node_type* p = static_cast(mNode.mpNext); + + while(p != &mNode) + { + node_type* const pTemp = p; + p = static_cast(p->mpNext); + pTemp->~node_type(); + EASTLFree(mAllocator, pTemp, sizeof(node_type)); + } + } + + + + + + /////////////////////////////////////////////////////////////////////// + // list + /////////////////////////////////////////////////////////////////////// + + template + inline list::list() + : base_type() + { + // Empty + } + + + template + inline list::list(const allocator_type& allocator) + : base_type(allocator) + { + // Empty + } + + + template + inline list::list(size_type n, const allocator_type& allocator) + : base_type(allocator) + { + //insert(iterator((ListNodeBase*)&mNode), n, value_type()); + DoInsertValues((ListNodeBase*)&mNode, n, value_type()); + } + + + template + inline list::list(size_type n, const value_type& value, const allocator_type& allocator) + : base_type(allocator) + { + // insert(iterator((ListNodeBase*)&mNode), n, value); + DoInsertValues((ListNodeBase*)&mNode, n, value); + } + + + template + inline list::list(const this_type& x) + : base_type(x.mAllocator) + { + //insert(iterator((ListNodeBase*)&mNode), const_iterator((ListNodeBase*)x.mNode.mpNext), const_iterator((ListNodeBase*)&x.mNode)); + DoInsert((ListNodeBase*)&mNode, const_iterator((const ListNodeBase*)x.mNode.mpNext), const_iterator((const ListNodeBase*)&x.mNode), false_type()); + } + + + template + template + list::list(InputIterator first, InputIterator last) + : base_type(EASTL_LIST_DEFAULT_ALLOCATOR) + { + //insert(iterator((ListNodeBase*)&mNode), first, last); + DoInsert((ListNodeBase*)&mNode, first, last, is_integral()); + } + + + template + typename list::iterator + inline list::begin() + { + return iterator((ListNodeBase*)mNode.mpNext); + } + + + template + inline typename list::const_iterator + list::begin() const + { + return const_iterator((ListNodeBase*)mNode.mpNext); + } + + + template + inline typename list::iterator + list::end() + { + return iterator((ListNodeBase*)&mNode); + } + + + template + inline typename list::const_iterator + list::end() const + { + return const_iterator((const ListNodeBase*)&mNode); + } + + + template + inline typename list::reverse_iterator + list::rbegin() + { + return reverse_iterator((ListNodeBase*)&mNode); + } + + + template + inline typename list::const_reverse_iterator + list::rbegin() const + { + return const_reverse_iterator((const ListNodeBase*)&mNode); + } + + + template + inline typename list::reverse_iterator + list::rend() + { + return reverse_iterator((ListNodeBase*)mNode.mpNext); + } + + + template + inline typename list::const_reverse_iterator + list::rend() const + { + return const_reverse_iterator((ListNodeBase*)mNode.mpNext); + } + + + template + inline typename list::reference + list::front() + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::front -- empty container"); + #endif + + return static_cast(mNode.mpNext)->mValue; + } + + + template + inline typename list::const_reference + list::front() const + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::front -- empty container"); + #endif + + return static_cast(mNode.mpNext)->mValue; + } + + + template + inline typename list::reference + list::back() + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::back -- empty container"); + #endif + + return static_cast(mNode.mpPrev)->mValue; + } + + + template + inline typename list::const_reference + list::back() const + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::back -- empty container"); + #endif + + return static_cast(mNode.mpPrev)->mValue; + } + + + template + inline bool list::empty() const + { + return static_cast(mNode.mpNext) == &mNode; + } + + + template + inline typename list::size_type + list::size() const + { + #if EASTL_LIST_SIZE_CACHE + return mSize; + #else + #if EASTL_DEBUG + const ListNodeBase* p = (ListNodeBase*)mNode.mpNext; + size_type n = 0; + while(p != (const ListNodeBase*)&mNode) + { + ++n; + p = (const ListNodeBase*)p->mpNext; + } + return n; + #else + // The following optimizes to slightly better code than the code above. + return (size_type)eastl::distance(const_iterator((const ListNodeBase*)mNode.mpNext), const_iterator((const ListNodeBase*)&mNode)); + #endif + #endif + } + + + template + typename list::this_type& + list::operator=(const this_type& x) + { + if(this != &x) + { + #if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; + #endif + + iterator current((ListNodeBase*)mNode.mpNext); + const_iterator first((const ListNodeBase*)x.mNode.mpNext); + const_iterator last((const ListNodeBase*)&x.mNode); + + while((current.mpNode != &mNode) && (first != last)) + { + *current = *first; + ++first; + ++current; + } + + if(first == last) + erase(current, (ListNodeBase*)&mNode); + else + insert((ListNodeBase*)&mNode, first, last); + } + return *this; + } + + + template + inline void list::assign(size_type n, const value_type& value) + { + DoAssignValues(n, value); + } + + + // It turns out that the C++ std::list specifies a two argument + // version of assign that takes (int size, int value). These are not + // iterators, so we need to do a template compiler trick to do the right thing. + template + template + inline void list::assign(InputIterator first, InputIterator last) + { + DoAssign(first, last, is_integral()); + } + + + template + inline void list::clear() + { + DoClear(); + DoInit(); + #if EASTL_LIST_SIZE_CACHE + mSize = 0; + #endif + } + + + template + inline void list::reset() + { + // The reset function is a special extension function which unilaterally + // resets the container to an empty state without freeing the memory of + // the contained objects. This is useful for very quickly tearing down a + // container built into scratch memory. + DoInit(); + #if EASTL_LIST_SIZE_CACHE + mSize = 0; + #endif + } + + + template + void list::resize(size_type n, const value_type& value) + { + iterator current((ListNodeBase*)mNode.mpNext); + size_type i = 0; + + while((current.mpNode != &mNode) && (i < n)) + { + ++current; + ++i; + } + if(i == n) + erase(current, (ListNodeBase*)&mNode); + else + insert((ListNodeBase*)&mNode, n - i, value); + } + + + template + inline void list::resize(size_type n) + { + resize(n, value_type()); + } + + + template + inline void list::push_front(const value_type& value) + { + DoInsertValue((ListNodeBase*)mNode.mpNext, value); + } + + + template + inline typename list::reference + list::push_front() + { + node_type* const pNode = DoCreateNode(); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)mNode.mpNext); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return static_cast(mNode.mpNext)->mValue; // Same as return front(); + } + + + template + inline void* list::push_front_uninitialized() + { + node_type* const pNode = DoAllocateNode(); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)mNode.mpNext); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return &pNode->mValue; + } + + + template + inline void list::pop_front() + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::pop_front -- empty container"); + #endif + + DoErase((ListNodeBase*)mNode.mpNext); + } + + + template + inline void list::push_back(const value_type& value) + { + DoInsertValue((ListNodeBase*)&mNode, value); + } + + + template + inline typename list::reference + list::push_back() + { + node_type* const pNode = DoCreateNode(); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)&mNode); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return static_cast(mNode.mpPrev)->mValue; // Same as return back(); + } + + + template + inline void* list::push_back_uninitialized() + { + node_type* const pNode = DoAllocateNode(); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)&mNode); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return &pNode->mValue; + } + + + template + inline void list::pop_back() + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(static_cast(mNode.mpNext) == &mNode)) + EASTL_FAIL_MSG("list::pop_back -- empty container"); + #endif + + DoErase((ListNodeBase*)mNode.mpPrev); + } + + + template + inline typename list::iterator + list::insert(iterator position) + { + node_type* const pNode = DoCreateNode(value_type()); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)position.mpNode); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return (ListNodeBase*)pNode; + } + + + template + inline typename list::iterator + list::insert(iterator position, const value_type& value) + { + node_type* const pNode = DoCreateNode(value); + ((ListNodeBase*)pNode)->insert((ListNodeBase*)position.mpNode); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + return (ListNodeBase*)pNode; + } + + + template + inline void list::insert(iterator position, size_type n, const value_type& value) + { + // To do: Get rid of DoInsertValues and put its implementation directly here. + DoInsertValues((ListNodeBase*)position.mpNode, n, value); + } + + + template + template + inline void list::insert(iterator position, InputIterator first, InputIterator last) + { + DoInsert((ListNodeBase*)position.mpNode, first, last, is_integral()); + } + + + template + inline typename list::iterator + list::erase(iterator position) + { + ++position; + DoErase((ListNodeBase*)position.mpNode->mpPrev); + return position; + } + + + template + typename list::iterator + list::erase(iterator first, iterator last) + { + while(first != last) + first = erase(first); + return last; + } + + + template + inline typename list::reverse_iterator + list::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + typename list::reverse_iterator + list::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + void list::remove(const value_type& value) + { + iterator current((ListNodeBase*)mNode.mpNext); + + while(current.mpNode != &mNode) + { + if(EASTL_LIKELY(!(*current == value))) + ++current; // We have duplicate '++current' statements here and below, but the logic here forces this. + else + { + ++current; + DoErase((ListNodeBase*)current.mpNode->mpPrev); + } + } + } + + + template + template + inline void list::remove_if(Predicate predicate) + { + for(iterator first((ListNodeBase*)mNode.mpNext), last((ListNodeBase*)&mNode); first != last; ) + { + iterator temp(first); + ++temp; + if(predicate(first.mpNode->mValue)) + DoErase((ListNodeBase*)first.mpNode); + first = temp; + } + } + + + template + inline void list::reverse() + { + ((ListNodeBase&)mNode).reverse(); + } + + + template + inline void list::splice(iterator position, this_type& x) + { + // Splicing operations cannot succeed if the two containers use unequal allocators. + // This issue is not addressed in the C++ 1998 standard but is discussed in the + // LWG defect reports, such as #431. There is no simple solution to this problem. + // One option is to throw an exception. For now our answer is simply: don't do this. + // EASTL_ASSERT(mAllocator == x.mAllocator); // Disabled because our member sort function uses splice but with allocators that may be unequal. There isn't a simple workaround aside from disabling this assert. + + // Disabled until the performance hit of this code is deemed worthwhile and until we are sure we want to disallow unequal allocators. + //#if EASTL_EXCEPTIONS_ENABLED + // if(EASTL_UNLIKELY(!(mAllocator == x.mAllocator))) + // throw std::runtime_error("list::splice -- unequal allocators"); + //#endif + + #if EASTL_LIST_SIZE_CACHE + if(x.mSize) + { + ((ListNodeBase*)position.mpNode)->splice((ListNodeBase*)x.mNode.mpNext, (ListNodeBase*)&x.mNode); + mSize += x.mSize; + x.mSize = 0; + } + #else + if(!x.empty()) + ((ListNodeBase*)position.mpNode)->splice((ListNodeBase*)x.mNode.mpNext, (ListNodeBase*)&x.mNode); + #endif + } + + + template + inline void list::splice(iterator position, list& x, iterator i) + { + (void)x; // Avoid potential unused variable warnings. + + // See notes in the other splice function regarding this assertion. + // EASTL_ASSERT(mAllocator == x.mAllocator); // Disabled because our member sort function uses splice but with allocators that may be unequal. There isn't a simple workaround aside from disabling this assert. + + // Disabled until the performance hit of this code is deemed worthwhile and until we are sure we want to disallow unequal allocators. + //#if EASTL_EXCEPTIONS_ENABLED + // if(EASTL_UNLIKELY(!(mAllocator == x.mAllocator))) + // throw std::runtime_error("list::splice -- unequal allocators"); + //#endif + + iterator i2(i); + ++i2; + if((position != i) && (position != i2)) + { + ((ListNodeBase*)position.mpNode)->splice((ListNodeBase*)i.mpNode, (ListNodeBase*)i2.mpNode); + + #if EASTL_LIST_SIZE_CACHE + ++mSize; + --x.mSize; + #endif + } + } + + + template + inline void list::splice(iterator position, this_type& x, iterator first, iterator last) + { + (void)x; // Avoid potential unused variable warnings. + + // See notes in the other splice function regarding this assertion. + // EASTL_ASSERT(mAllocator == x.mAllocator); // Disabled because our member sort function uses splice but with allocators that may be unequal. There isn't a simple workaround aside from disabling this assert. + + // Disabled until the performance hit of this code is deemed worthwhile and until we are sure we want to disallow unequal allocators. + //#if EASTL_EXCEPTIONS_ENABLED + // if(EASTL_UNLIKELY(!(mAllocator == x.mAllocator))) + // throw std::runtime_error("list::splice -- unequal allocators"); + //#endif + + #if EASTL_LIST_SIZE_CACHE + const size_type n = (size_type)eastl::distance(first, last); + + if(n) + { + ((ListNodeBase*)position.mpNode)->splice((ListNodeBase*)first.mpNode, (ListNodeBase*)last.mpNode); + mSize += n; + x.mSize -= n; + } + #else + if(first != last) + ((ListNodeBase*)position.mpNode)->splice((ListNodeBase*)first.mpNode, (ListNodeBase*)last.mpNode); + #endif + } + + + template + inline void list::swap(this_type& x) + { + if(mAllocator == x.mAllocator) // If allocators are equivalent... + { + // We leave mAllocator as-is. + ListNodeBase::swap((ListNodeBase&)mNode, (ListNodeBase&)x.mNode); // We need to implement a special swap because we can't do a shallow swap. + + #if EASTL_LIST_SIZE_CACHE + eastl::swap(mSize, x.mSize); + #endif + } + else // else swap the contents. + { + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + + // Alternative implementation: + //const iterator pos((ListNodeBase*)mNode.mpNext); + //splice(pos, x); + //x.splice(x.begin(), *this, pos, iterator((ListNodeBase*)&mNode)); + } + } + + + template + void list::merge(this_type& x) + { + if(this != &x) + { + iterator first(begin()); + iterator firstX(x.begin()); + const iterator last(end()); + const iterator lastX(x.end()); + + while((first != last) && (firstX != lastX)) + { + if(*firstX < *first) + { + iterator next(firstX); + + splice(first, x, firstX, ++next); + firstX = next; + } + else + ++first; + } + + if(firstX != lastX) + splice(last, x, firstX, lastX); + } + } + + + template + template + void list::merge(this_type& x, Compare compare) + { + if(this != &x) + { + iterator first(begin()); + iterator firstX(x.begin()); + const iterator last(end()); + const iterator lastX(x.end()); + + while((first != last) && (firstX != lastX)) + { + if(compare(*firstX, *first)) + { + iterator next(firstX); + + splice(first, x, firstX, ++next); + firstX = next; + } + else + ++first; + } + + if(firstX != lastX) + splice(last, x, firstX, lastX); + } + } + + + template + void list::unique() + { + iterator first(begin()); + const iterator last(end()); + + if(first != last) + { + iterator next(first); + + while(++next != last) + { + if(*first == *next) + DoErase((ListNodeBase*)next.mpNode); + else + first = next; + next = first; + } + } + } + + + template + template + void list::unique(BinaryPredicate predicate) + { + iterator first(begin()); + const iterator last(end()); + + if(first != last) + { + iterator next(first); + + while(++next != last) + { + if(predicate(*first, *next)) + DoErase((ListNodeBase*)next.mpNode); + else + first = next; + next = first; + } + } + } + + + template + void list::sort() + { + // We implement the algorithm employed by Chris Caulfield whereby we use recursive + // function calls to sort the list. The sorting of a very large list may fail due to stack overflow + // if the stack is exhausted. The limit depends on the platform and the avaialable stack space. + + // Easier-to-understand version of the 'if' statement: + // iterator i(begin()); + // if((i != end()) && (++i != end())) // If the size is >= 2 (without calling the more expensive size() function)... + + // Faster, more inlinable version of the 'if' statement: + if((static_cast(mNode.mpNext) != &mNode) && + (static_cast(mNode.mpNext) != static_cast(mNode.mpPrev))) + { + // We may have a stack space problem here if sizeof(this_type) is large (usually due to + // usage of a fixed_list). The only current resolution is to find an alternative way of + // doing things. I (Paul Pedriana) believe that the best long-term solution to this problem + // is to revise this sort function to not use this_type but instead use a ListNodeBase + // which involves no allocators and sort at that level, entirely with node pointers. + + // Split the array into 2 roughly equal halves. + this_type leftList(get_allocator()); // This should cause no memory allocation. + this_type rightList(get_allocator()); + + // We find an iterator which is in the middle of the list. The fastest way to do + // this is to iterate from the base node both forwards and backwards with two + // iterators and stop when they meet each other. Recall that our size() function + // is not O(1) but is instead O(n), at least when EASTL_LIST_SIZE_CACHE is disabled. + #if EASTL_LIST_SIZE_CACHE + iterator mid(begin()); + eastl::advance(mid, size() / 2); + #else + iterator mid(begin()), tail(end()); + + while((mid != tail) && (++mid != tail)) + --tail; + #endif + + // Move the left half of this into leftList and the right half into rightList. + leftList.splice(leftList.begin(), *this, begin(), mid); + rightList.splice(rightList.begin(), *this); + + // Sort the sub-lists. + leftList.sort(); + rightList.sort(); + + // Merge the two halves into this list. + splice(begin(), leftList); + merge(rightList); + } + } + + + template + template + void list::sort(Compare compare) + { + // We implement the algorithm employed by Chris Caulfield whereby we use recursive + // function calls to sort the list. The sorting of a very large list may fail due to stack overflow + // if the stack is exhausted. The limit depends on the platform and the avaialble stack space. + + // Easier-to-understand version of the 'if' statement: + // iterator i(begin()); + // if((i != end()) && (++i != end())) // If the size is >= 2 (without calling the more expensive size() function)... + + // Faster, more inlinable version of the 'if' statement: + if((static_cast(mNode.mpNext) != &mNode) && + (static_cast(mNode.mpNext) != static_cast(mNode.mpPrev))) + { + // We may have a stack space problem here if sizeof(this_type) is large (usually due to + // usage of a fixed_list). The only current resolution is to find an alternative way of + // doing things. I (Paul Pedriana) believe that the best long-term solution to this problem + // is to revise this sort function to not use this_type but instead use a ListNodeBase + // which involves no allocators and sort at that level, entirely with node pointers. + + // Split the array into 2 roughly equal halves. + this_type leftList(get_allocator()); // This should cause no memory allocation. + this_type rightList(get_allocator()); + + // We find an iterator which is in the middle of the list. The fastest way to do + // this is to iterate from the base node both forwards and backwards with two + // iterators and stop when they meet each other. Recall that our size() function + // is not O(1) but is instead O(n), at least when EASTL_LIST_SIZE_CACHE is disabled. + #if EASTL_LIST_SIZE_CACHE + iterator mid(begin()); + eastl::advance(mid, size() / 2); + #else + iterator mid(begin()), tail(end()); + + while((mid != tail) && (++mid != tail)) + --tail; + #endif + + // Move the left half of this into leftList and the right half into rightList. + leftList.splice(leftList.begin(), *this, begin(), mid); + rightList.splice(rightList.begin(), *this); + + // Sort the sub-lists. + leftList.sort(compare); + rightList.sort(compare); + + // Merge the two halves into this list. + splice(begin(), leftList); + merge(rightList, compare); + } + } + + + template + inline typename list::node_type* + list::DoCreateNode(const value_type& value) + { + node_type* const pNode = DoAllocateNode(); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + ::new(&pNode->mValue) value_type(value); + } + catch(...) + { + DoFreeNode(pNode); + throw; + } + #else + ::new(&pNode->mValue) value_type(value); + #endif + + return pNode; + } + + + template + inline typename list::node_type* + list::DoCreateNode() + { + node_type* const pNode = DoAllocateNode(); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + ::new(&pNode->mValue) value_type(); + } + catch(...) + { + DoFreeNode(pNode); + throw; + } + #else + ::new(&pNode->mValue) value_type; + #endif + + return pNode; + } + + + template + template + inline void list::DoAssign(Integer n, Integer value, true_type) + { + DoAssignValues(static_cast(n), static_cast(value)); + } + + + template + template + void list::DoAssign(InputIterator first, InputIterator last, false_type) + { + node_type* pNode = static_cast(mNode.mpNext); + + for(; (pNode != &mNode) && (first != last); ++first) + { + pNode->mValue = *first; + pNode = static_cast(pNode->mpNext); + } + + if(first == last) + erase(iterator((ListNodeBase*)pNode), (ListNodeBase*)&mNode); + else + DoInsert((ListNodeBase*)&mNode, first, last, false_type()); + } + + + template + void list::DoAssignValues(size_type n, const value_type& value) + { + node_type* pNode = static_cast(mNode.mpNext); + + for(; (pNode != &mNode) && (n > 0); --n) + { + pNode->mValue = value; + pNode = static_cast(pNode->mpNext); + } + + if(n) + DoInsertValues((ListNodeBase*)&mNode, n, value); + else + erase(iterator((ListNodeBase*)pNode), (ListNodeBase*)&mNode); + } + + + template + template + inline void list::DoInsert(ListNodeBase* pNode, Integer n, Integer value, true_type) + { + DoInsertValues(pNode, static_cast(n), static_cast(value)); + } + + + template + template + inline void list::DoInsert(ListNodeBase* pNode, InputIterator first, InputIterator last, false_type) + { + for(; first != last; ++first) + DoInsertValue(pNode, *first); + } + + + template + inline void list::DoInsertValues(ListNodeBase* pNode, size_type n, const value_type& value) + { + for(; n > 0; --n) + DoInsertValue(pNode, value); + } + + + template + inline void list::DoInsertValue(ListNodeBase* pNode, const value_type& value) + { + node_type* const pNodeNew = DoCreateNode(value); + ((ListNodeBase*)pNodeNew)->insert((ListNodeBase*)pNode); + #if EASTL_LIST_SIZE_CACHE + ++mSize; + #endif + } + + + template + inline void list::DoErase(ListNodeBase* pNode) + { + pNode->remove(); + ((node_type*)pNode)->~node_type(); + DoFreeNode(((node_type*)pNode)); + #if EASTL_LIST_SIZE_CACHE + --mSize; + #endif + } + + + template + inline bool list::validate() const + { + #if EASTL_LIST_SIZE_CACHE + size_type n = 0; + + for(const_iterator i(begin()), iEnd(end()); i != iEnd; ++i) + ++n; + + if(n != mSize) + return false; + #endif + + // To do: More validation. + return true; + } + + + template + inline int list::validate_iterator(const_iterator i) const + { + // To do: Come up with a more efficient mechanism of doing this. + + for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp) + { + if(temp == i) + return (isf_valid | isf_current | isf_can_dereference); + } + + if(i == end()) + return (isf_valid | isf_current); + + return isf_none; + } + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + bool operator==(const list& a, const list& b) + { + typename list::const_iterator ia = a.begin(); + typename list::const_iterator ib = b.begin(); + typename list::const_iterator enda = a.end(); + + #if EASTL_LIST_SIZE_CACHE + if(a.size() == b.size()) + { + while((ia != enda) && (*ia == *ib)) + { + ++ia; + ++ib; + } + return (ia == enda); + } + return false; + #else + typename list::const_iterator endb = b.end(); + + while((ia != enda) && (ib != endb) && (*ia == *ib)) + { + ++ia; + ++ib; + } + return (ia == enda) && (ib == endb); + #endif + } + + template + bool operator<(const list& a, const list& b) + { + return eastl::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); + } + + template + bool operator!=(const list& a, const list& b) + { + return !(a == b); + } + + template + bool operator>(const list& a, const list& b) + { + return b < a; + } + + template + bool operator<=(const list& a, const list& b) + { + return !(b < a); + } + + template + bool operator>=(const list& a, const list& b) + { + return !(a < b); + } + + template + void swap(list& a, list& b) + { + a.swap(b); + } + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/map.h b/lib/eastl/include/EASTL/map.h new file mode 100644 index 0000000..d94ca37 --- /dev/null +++ b/lib/eastl/include/EASTL/map.h @@ -0,0 +1,520 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/map.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written by Paul Pedriana. +////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_MAP_H +#define EASTL_MAP_H + + + +#include +#include +#include +#include + + + +namespace eastl +{ + + /// EASTL_MAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_MAP_DEFAULT_NAME + #define EASTL_MAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " map" // Unless the user overrides something, this is "EASTL map". + #endif + + + /// EASTL_MULTIMAP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_MULTIMAP_DEFAULT_NAME + #define EASTL_MULTIMAP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " multimap" // Unless the user overrides something, this is "EASTL multimap". + #endif + + + /// EASTL_MAP_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_MAP_DEFAULT_ALLOCATOR + #define EASTL_MAP_DEFAULT_ALLOCATOR allocator_type(EASTL_MAP_DEFAULT_NAME) + #endif + + /// EASTL_MULTIMAP_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_MULTIMAP_DEFAULT_ALLOCATOR + #define EASTL_MULTIMAP_DEFAULT_ALLOCATOR allocator_type(EASTL_MULTIMAP_DEFAULT_NAME) + #endif + + + + /// map + /// + /// Implements a canonical map. + /// + /// The large majority of the implementation of this class is found in the rbtree + /// base class. We control the behaviour of rbtree via template parameters. + /// + /// Pool allocation + /// If you want to make a custom memory pool for a map container, your pool + /// needs to contain items of type map::node_type. So if you have a memory + /// pool that has a constructor that takes the size of pool items and the + /// count of pool items, you would do this (assuming that MemoryPool implements + /// the Allocator interface): + /// typedef map, MemoryPool> WidgetMap; // Delare your WidgetMap type. + /// MemoryPool myPool(sizeof(WidgetMap::node_type), 100); // Make a pool of 100 Widget nodes. + /// WidgetMap myMap(&myPool); // Create a map that uses the pool. + /// + template , typename Allocator = EASTLAllocatorType> + class map + : public rbtree, Compare, Allocator, eastl::use_first >, true, true> + { + public: + typedef rbtree, Compare, Allocator, + eastl::use_first >, true, true> base_type; + typedef map this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::key_type key_type; + typedef T mapped_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::insert_return_type insert_return_type; + typedef typename base_type::extract_key extract_key; + // Other types are inherited from the base class. + + using base_type::begin; + using base_type::end; + using base_type::find; + using base_type::lower_bound; + using base_type::upper_bound; + using base_type::mCompare; + + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x has a bug which we work around. + using base_type::insert; + using base_type::erase; + #endif + + public: + map(const allocator_type& allocator = EASTL_MAP_DEFAULT_ALLOCATOR); + map(const Compare& compare, const allocator_type& allocator = EASTL_MAP_DEFAULT_ALLOCATOR); + map(const this_type& x); + + template + map(Iterator itBegin, Iterator itEnd); // allocator arg removed because VC7.1 fails on the default arg. To consider: Make a second version of this function without a default arg. + + public: + /// This is an extension to the C++ standard. We insert a default-constructed + /// element with the given key. The reason for this is that we can avoid the + /// potentially expensive operation of creating and/or copying a mapped_type + /// object on the stack. + insert_return_type insert(const Key& key); + + #if defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around) + template + void insert(InputIterator first, InputIterator last) { return base_type::insert(first, last); } + insert_return_type insert(const value_type& value) { return base_type::insert(value); } + iterator insert(iterator position, const value_type& value) { return base_type::insert(position, value); } + iterator erase(iterator position) { return base_type::erase(position); } + iterator erase(iterator first, iterator last) { return base_type::erase(first, last); } + #endif + + size_type erase(const Key& key); + size_type count(const Key& key) const; + + eastl::pair equal_range(const Key& key); + eastl::pair equal_range(const Key& key) const; + + T& operator[](const Key& key); // Of map, multimap, set, and multimap, only map has operator[]. + + }; // map + + + + + + + /// multimap + /// + /// Implements a canonical multimap. + /// + /// The large majority of the implementation of this class is found in the rbtree + /// base class. We control the behaviour of rbtree via template parameters. + /// + /// Pool allocation + /// If you want to make a custom memory pool for a multimap container, your pool + /// needs to contain items of type multimap::node_type. So if you have a memory + /// pool that has a constructor that takes the size of pool items and the + /// count of pool items, you would do this (assuming that MemoryPool implements + /// the Allocator interface): + /// typedef multimap, MemoryPool> WidgetMap; // Delare your WidgetMap type. + /// MemoryPool myPool(sizeof(WidgetMap::node_type), 100); // Make a pool of 100 Widget nodes. + /// WidgetMap myMap(&myPool); // Create a map that uses the pool. + /// + template , typename Allocator = EASTLAllocatorType> + class multimap + : public rbtree, Compare, Allocator, eastl::use_first >, true, false> + { + public: + typedef rbtree, Compare, Allocator, + eastl::use_first >, true, false> base_type; + typedef multimap this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::key_type key_type; + typedef T mapped_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::node_type node_type; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::allocator_type allocator_type; + typedef typename base_type::insert_return_type insert_return_type; + typedef typename base_type::extract_key extract_key; + // Other types are inherited from the base class. + + using base_type::begin; + using base_type::end; + using base_type::find; + using base_type::lower_bound; + using base_type::upper_bound; + using base_type::mCompare; + + #if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x has a bug which we work around. + using base_type::insert; + using base_type::erase; + #endif + + public: + multimap(const allocator_type& allocator = EASTL_MULTIMAP_DEFAULT_ALLOCATOR); + multimap(const Compare& compare, const allocator_type& allocator = EASTL_MULTIMAP_DEFAULT_ALLOCATOR); + multimap(const this_type& x); + + template + multimap(Iterator itBegin, Iterator itEnd); // allocator arg removed because VC7.1 fails on the default arg. To consider: Make a second version of this function without a default arg. + + public: + /// This is an extension to the C++ standard. We insert a default-constructed + /// element with the given key. The reason for this is that we can avoid the + /// potentially expensive operation of creating and/or copying a mapped_type + /// object on the stack. + insert_return_type insert(const Key& key); + + #if defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around) + template + void insert(InputIterator first, InputIterator last) { return base_type::insert(first, last); } + insert_return_type insert(const value_type& value) { return base_type::insert(value); } + iterator insert(iterator position, const value_type& value) { return base_type::insert(position, value); } + iterator erase(iterator position) { return base_type::erase(position); } + iterator erase(iterator first, iterator last) { return base_type::erase(first, last); } + #endif + + size_type erase(const Key& key); + size_type count(const Key& key) const; + + eastl::pair equal_range(const Key& key); + eastl::pair equal_range(const Key& key) const; + + /// equal_range_small + /// This is a special version of equal_range which is optimized for the + /// case of there being few or no duplicated keys in the tree. + eastl::pair equal_range_small(const Key& key); + eastl::pair equal_range_small(const Key& key) const; + + }; // multimap + + + + + + /////////////////////////////////////////////////////////////////////// + // map + /////////////////////////////////////////////////////////////////////// + + template + inline map::map(const allocator_type& allocator) + : base_type(allocator) { } + + + template + inline map::map(const Compare& compare, const allocator_type& allocator) + : base_type(compare, allocator) { } + + + template + inline map::map(const this_type& x) + : base_type(x) { } + + + template + template + inline map::map(Iterator itBegin, Iterator itEnd) + : base_type(itBegin, itEnd, Compare(), EASTL_MAP_DEFAULT_ALLOCATOR) { } + + + template + inline typename map::insert_return_type + map::insert(const Key& key) + { + return base_type::DoInsertKey(key, true_type()); + } + + + template + inline typename map::size_type + map::erase(const Key& key) + { + const iterator it(find(key)); + + if(it != end()) // If it exists... + { + base_type::erase(it); + return 1; + } + return 0; + } + + + template + inline typename map::size_type + map::count(const Key& key) const + { + const const_iterator it(find(key)); + return (it != end()) ? 1 : 0; + } + + + template + inline eastl::pair::iterator, + typename map::iterator> + map::equal_range(const Key& key) + { + // The resulting range will either be empty or have one element, + // so instead of doing two tree searches (one for lower_bound and + // one for upper_bound), we do just lower_bound and see if the + // result is a range of size zero or one. + const iterator itLower(lower_bound(key)); + + if((itLower == end()) || mCompare(key, itLower.mpNode->mValue.first)) // If at the end or if (key is < itLower)... + return eastl::pair(itLower, itLower); + + iterator itUpper(itLower); + return eastl::pair(itLower, ++itUpper); + } + + + template + inline eastl::pair::const_iterator, + typename map::const_iterator> + map::equal_range(const Key& key) const + { + // See equal_range above for comments. + const const_iterator itLower(lower_bound(key)); + + if((itLower == end()) || mCompare(key, itLower.mpNode->mValue.first)) // If at the end or if (key is < itLower)... + return eastl::pair(itLower, itLower); + + const_iterator itUpper(itLower); + return eastl::pair(itLower, ++itUpper); + } + + + template + inline T& map::operator[](const Key& key) + { + iterator itLower(lower_bound(key)); // itLower->first is >= key. + + if((itLower == end()) || mCompare(key, (*itLower).first)) + { + itLower = base_type::insert(itLower, value_type(key, T())); + + // To do: Convert this to use the more efficient: + // itLower = DoInsertKey(itLower, key, true_type()); + // when we gain confidence in that function. + } + + return (*itLower).second; + + // Reference implementation of this function, which may not be as fast: + //iterator it(base_type::insert(eastl::pair(key, T())).first); + //return it->second; + } + + + + + + + /////////////////////////////////////////////////////////////////////// + // multimap + /////////////////////////////////////////////////////////////////////// + + template + inline multimap::multimap(const allocator_type& allocator) + : base_type(allocator) + { + // Empty + } + + + template + inline multimap::multimap(const Compare& compare, const allocator_type& allocator) + : base_type(compare, allocator) + { + // Empty + } + + + template + inline multimap::multimap(const this_type& x) + : base_type(x) + { + // Empty + } + + + template + template + inline multimap::multimap(Iterator itBegin, Iterator itEnd) + : base_type(itBegin, itEnd, Compare(), EASTL_MULTIMAP_DEFAULT_ALLOCATOR) + { + // Empty + } + + + template + inline typename multimap::insert_return_type + multimap::insert(const Key& key) + { + return base_type::DoInsertKey(key, false_type()); + } + + + template + inline typename multimap::size_type + multimap::erase(const Key& key) + { + const eastl::pair range(equal_range(key)); + const size_type n = (size_type)eastl::distance(range.first, range.second); + base_type::erase(range.first, range.second); + return n; + } + + + template + inline typename multimap::size_type + multimap::count(const Key& key) const + { + const eastl::pair range(equal_range(key)); + return (size_type)eastl::distance(range.first, range.second); + } + + + template + inline eastl::pair::iterator, + typename multimap::iterator> + multimap::equal_range(const Key& key) + { + // There are multiple ways to implement equal_range. The implementation mentioned + // in the C++ standard and which is used by most (all?) commercial STL implementations + // is this: + // return eastl::pair(lower_bound(key), upper_bound(key)); + // + // This does two tree searches -- one for the lower bound and one for the + // upper bound. This works well for the case whereby you have a large container + // and there are lots of duplicated values. We provide an alternative version + // of equal_range called equal_range_small for cases where the user is confident + // that the number of duplicated items is only a few. + + return eastl::pair(lower_bound(key), upper_bound(key)); + } + + + template + inline eastl::pair::const_iterator, + typename multimap::const_iterator> + multimap::equal_range(const Key& key) const + { + // See comments above in the non-const version of equal_range. + return eastl::pair(lower_bound(key), upper_bound(key)); + } + + + template + inline eastl::pair::iterator, + typename multimap::iterator> + multimap::equal_range_small(const Key& key) + { + // We provide alternative version of equal_range here which works faster + // for the case where there are at most small number of potential duplicated keys. + const iterator itLower(lower_bound(key)); + iterator itUpper(itLower); + + while((itUpper != end()) && !mCompare(key, itUpper.mpNode->mValue.first)) + ++itUpper; + + return eastl::pair(itLower, itUpper); + } + + + template + inline eastl::pair::const_iterator, + typename multimap::const_iterator> + multimap::equal_range_small(const Key& key) const + { + // We provide alternative version of equal_range here which works faster + // for the case where there are at most small number of potential duplicated keys. + const const_iterator itLower(lower_bound(key)); + const_iterator itUpper(itLower); + + while((itUpper != end()) && !mCompare(key, itUpper.mpNode->mValue.first)) + ++itUpper; + + return eastl::pair(itLower, itUpper); + } + + + + +} // namespace eastl + + +#endif // Header include guard + + + + diff --git a/lib/eastl/include/EASTL/memory.h b/lib/eastl/include/EASTL/memory.h new file mode 100644 index 0000000..7f1d96c --- /dev/null +++ b/lib/eastl/include/EASTL/memory.h @@ -0,0 +1,698 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/memory.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +// The uninitialized_move function was written by Ryan Ingram. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements the following functions from the C++ standard that +// are found in the header: +// +// Temporary memory: +// get_temporary_buffer +// return_temporary_buffer +// +// Uninitialized operations: +// These are the same as the copy, fill, and fill_n algorithms, except that +// they *construct* the destination with the source values rather than assign +// the destination with the source values. +// +// uninitialized_copy +// uninitialized_fill +// uninitialized_fill_n +// uninitialized_move - Extention to standard functionality. +// uninitialized_copy_ptr - Extention to standard functionality. +// uninitialized_fill_ptr - Extention to standard functionality. +// uninitialized_fill_n_ptr - Extention to standard functionality. +// uninitialized_copy_fill - Extention to standard functionality. +// uninitialized_fill_copy - Extention to standard functionality. +// uninitialized_copy_copy - Extention to standard functionality. +// +// In-place destructor helpers: +// destruct(T*) +// destruct(first, last) +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_MEMORY_H +#define EASTL_MEMORY_H + + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #pragma warning(push, 0) +#endif +#include +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +#ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc +#endif + + +namespace eastl +{ + + /// EASTL_TEMP_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_TEMP_DEFAULT_NAME + #define EASTL_TEMP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " temp" // Unless the user overrides something, this is "EASTL temp". + #endif + + + /// get_temporary_buffer + /// + /// From the C++ standard, section 20.4.3: + /// 1 Effects: Obtains a pointer to storage sufficient to store up to n adjacent T objects. + /// 2 Returns: A pair containing the buffer's address and capacity (in the units of sizeof(T)), + /// or a pair of 0 values if no storage can be obtained. + /// + /// Note: The return value is space to hold T elements, but no T elements are constructed. + /// + /// Our implementation here differs slightly in that we have alignment, alignmentOffset, and pName arguments. + /// Note that you can use the EASTL_NAME_VAL macro to make names go away in release builds. + /// + /// Example usage: + /// pair pr = get_temporary_buffer(100, 0, 0, EASTL_NAME_VAL("Temp int array")); + /// memset(pr.first, 0, 100 * sizeof(int)); + /// return_temporary_buffer(pr.first); + /// + template + pair get_temporary_buffer(ptrdiff_t n, size_t alignment = 0, size_t alignmentOffset = 0, const char* pName = EASTL_TEMP_DEFAULT_NAME) + { + EASTLAllocatorType allocator(*EASTLAllocatorDefault(), pName); + return eastl::pair(static_cast(EASTLAllocAligned(allocator, n * sizeof(T), alignment, alignmentOffset)), n); + } + + + /// return_temporary_buffer + /// + /// From the C++ standard, section 20.4.3: + /// 3 Effects: Deallocates the buffer to which p points. + /// 4 Requires: The buffer shall have been previously allocated by get_temporary_buffer. + /// + /// Note: This function merely frees space and does not destruct any T elements. + /// + /// Example usage: + /// pair pr = get_temporary_buffer(300); + /// memset(pr.first, 0, 300 * sizeof(int)); + /// return_temporary_buffer(pr.first, pr.second); + /// + template + void return_temporary_buffer(T* p, ptrdiff_t n = 0) + { + EASTLAllocatorType& allocator(*EASTLAllocatorDefault()); + EASTLFree(allocator, p, n * sizeof(T)); + } + + + + /// uninitialized_move + /// + /// uninitialized_move takes a constructed sequence of objects and an + /// uninitialized destination buffer. In the case of any exception thrown + /// while moving the objects, any newly constructed objects are guaranteed + /// to be destructed and the input left fully constructed. + /// + /// In the case where you need to do multiple moves atomically, split the + /// calls into uninitialized_move_start/abort/commit. + /// + /// uninitialized_move_start can possibly throw an exception. If it does, + /// you don't need to do anything. However, if it returns without throwing + /// an exception you need to guarantee that either uninitialize_move_abort + /// or uninitialized_move_commit is called. + /// + /// Both uninitialize_move_abort and uninitialize_move_commit are + /// guaranteed to not throw C++ exceptions. + + template + struct uninitialized_move_impl + { + template + static ForwardIteratorDest do_move_start(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) + { + typedef typename eastl::iterator_traits::value_type value_type; + + #if EASTL_EXCEPTIONS_ENABLED + ForwardIteratorDest origDest(dest); + try + { + for(; first != last; ++first, ++dest) + ::new(&*dest) value_type(*first); + } + catch(...) + { + for(; origDest < dest; ++origDest) + origDest->~value_type(); + throw; + } + #else + for(; first != last; ++first, ++dest) + ::new(&*dest) value_type(*first); + #endif + + return dest; + } + + template + static ForwardIteratorDest do_move_commit(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) //throw() + { + typedef typename eastl::iterator_traits::value_type value_type; + for(; first != last; ++first, ++dest) + first->~value_type(); + + return dest; + } + + template + static ForwardIteratorDest do_move_abort(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) //throw() + { + typedef typename eastl::iterator_traits::value_type value_type; + for(; first != last; ++first, ++dest) + dest->~value_type(); + return dest; + } + }; + + template <> + struct uninitialized_move_impl + { + template + static T* do_move_start(T* first, T* last, T* dest) + { + return (T*)memcpy(dest, first, (size_t)((uintptr_t)last - (uintptr_t)first)) + (last - first); + } + + template + static T* do_move_commit(T* first, T* last, T* dest) + { + return dest + (last - first); + } + + template + static T* do_move_abort(T* first, T* last, T* dest) + { + return dest + (last - first); + } + }; + + + /// uninitialized_move_start, uninitialized_move_commit, uninitialized_move_abort + /// + /// After calling uninitialized_move_start, if it doesn't throw an exception, + /// both the source and destination iterators point to undefined data. If it + /// does throw an exception, the destination remains uninitialized and the source + /// is as it was before. + /// + /// In order to make the iterators valid again you need to call either uninitialized_move_abort + /// or uninitialized_move_commit. The abort call makes the original source + /// iterator valid again, and commit makes the destination valid. Both abort + /// and commit are guaranteed to not throw C++ exceptions. + /// + /// Example usage: + /// iterator dest2 = uninitialized_move_start(first, last, dest); + /// try { + /// // some code here that might throw an exception + /// } + /// catch(...) + /// { + /// uninitialized_move_abort(first, last, dest); + /// throw; + /// } + /// uninitialized_move_commit(first, last, dest); + /// + template + inline ForwardIteratorDest uninitialized_move_start(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) + { + typedef typename eastl::iterator_traits::iterator_category IC; + typedef typename eastl::iterator_traits::value_type value_type_input; + typedef typename eastl::iterator_traits::value_type value_type_output; + + const bool bHasTrivialMove = type_and::value, + is_pointer::value, + is_pointer::value, + is_same::value>::value; + + return eastl::uninitialized_move_impl::do_move_start(first, last, dest); + } + + template + inline ForwardIteratorDest uninitialized_move_commit(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) + { + typedef typename eastl::iterator_traits::iterator_category IC; + typedef typename eastl::iterator_traits::value_type value_type_input; + typedef typename eastl::iterator_traits::value_type value_type_output; + + const bool bHasTrivialMove = type_and::value, + is_pointer::value, + is_pointer::value, + is_same::value>::value; + + return eastl::uninitialized_move_impl::do_move_commit(first, last, dest); + } + + template + inline ForwardIteratorDest uninitialized_move_abort(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) + { + typedef typename eastl::iterator_traits::iterator_category IC; + typedef typename eastl::iterator_traits::value_type value_type_input; + typedef typename eastl::iterator_traits::value_type value_type_output; + + const bool bHasTrivialMove = type_and::value, + is_pointer::value, + is_pointer::value, + is_same::value>::value; + + return eastl::uninitialized_move_impl::do_move_abort(first, last, dest); + } + + /// uninitialized_move + /// + /// uninitialized_move takes a constructed sequence of objects and an + /// uninitialized destination buffer. In the case of any exception thrown + /// while moving the objects, any newly constructed objects are guaranteed + /// to be destructed and the input left as it was before. + /// + template + inline ForwardIteratorDest uninitialized_move(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) + { + ForwardIteratorDest result = uninitialized_move_start(first, last, dest); + uninitialized_move_commit(first, last, dest); + + return result; + } + + + + + + // uninitialized_copy + // + template + inline ForwardIterator uninitialized_copy_impl(InputIterator first, InputIterator last, ForwardIterator dest, true_type) + { + return eastl::copy(first, last, dest); // The copy() in turn will use memcpy for POD types. + } + + template + inline ForwardIterator uninitialized_copy_impl(InputIterator first, InputIterator last, ForwardIterator dest, false_type) + { + typedef typename eastl::iterator_traits::value_type value_type; + ForwardIterator currentDest(dest); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + for(; first != last; ++first, ++currentDest) + ::new(&*currentDest) value_type(*first); + } + catch(...) + { + for(; dest < currentDest; ++dest) + dest->~value_type(); + throw; + } + #else + for(; first != last; ++first, ++currentDest) + ::new(&*currentDest) value_type(*first); + #endif + + return currentDest; + } + + /// uninitialized_copy + /// + /// Copies a source range to a destination, copy-constructing the destination with + /// the source values (and not *assigning* the destination with the source values). + /// Returns the end of the destination range (i.e. dest + (last - first)). + /// + /// Declaration: + /// template + /// ForwardIterator uninitialized_copy(InputIterator sourceFirst, InputIterator sourceLast, ForwardIterator destination); + /// + /// Example usage: + /// SomeClass* pArray = malloc(10 * sizeof(SomeClass)); + /// uninitialized_copy(pSourceDataBegin, pSourceDataBegin + 10, pArray); + /// + template + inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result) + { + typedef typename eastl::iterator_traits::value_type value_type; + + // Note: has_trivial_assign isn't actually the right thing to use here, as it + // refers to assignment as opposed to construction. Bug Paul Pedriana if this + // is becoming a problem. In the meantime, this code assumes that if has_trivial_assign + // is present for a type, then has_trivial_copy is as well. + return uninitialized_copy_impl(first, last, result, has_trivial_assign()); + } + + /// uninitialized_copy_ptr + /// + /// This is a specialization of uninitialized_copy for iterators that are pointers. + /// It exists so that we can declare a value_type for the iterator, which you + /// can't do with a pointer by itself. + /// + template + inline Result uninitialized_copy_ptr(First first, Last last, Result result) + { + typedef typename eastl::iterator_traits >::value_type value_type; + const generic_iterator i(uninitialized_copy_impl(generic_iterator(first), + generic_iterator(last), + generic_iterator(result), + has_trivial_assign())); + return i.base(); + } + + + + + // uninitialized_fill + // + template + inline void uninitialized_fill_impl(ForwardIterator first, ForwardIterator last, const T& value, true_type) + { + eastl::fill(first, last, value); + } + + template + void uninitialized_fill_impl(ForwardIterator first, ForwardIterator last, const T& value, false_type) + { + typedef typename eastl::iterator_traits::value_type value_type; + ForwardIterator currentDest(first); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + for(; currentDest != last; ++currentDest) + ::new(&*currentDest) value_type(value); + } + catch(...) + { + for(; first < currentDest; ++first) + first->~value_type(); + throw; + } + #else + for(; currentDest != last; ++currentDest) + ::new(&*currentDest) value_type(value); + #endif + } + + /// uninitialized_fill + /// + /// Copy-constructs the elements in the destination range with the given input value. + /// Returns void. It wouldn't be useful to return the end of the destination range, + /// as that is the same as the 'last' input parameter. + /// + /// Declaration: + /// template + /// void uninitialized_fill(ForwardIterator destinationFirst, ForwardIterator destinationLast, const T& value); + /// + template + inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& value) + { + typedef typename eastl::iterator_traits::value_type value_type; + uninitialized_fill_impl(first, last, value, has_trivial_assign()); + } + + /// uninitialized_fill_ptr + /// + /// This is a specialization of uninitialized_fill for iterators that are pointers. + /// It exists so that we can declare a value_type for the iterator, which you + /// can't do with a pointer by itself. + /// + template + inline void uninitialized_fill_ptr(T* first, T* last, const T& value) + { + typedef typename eastl::iterator_traits >::value_type value_type; + uninitialized_fill_impl(generic_iterator(first), generic_iterator(last), value, has_trivial_assign()); + } + + + + + // uninitialized_fill_n + // + template + inline void uninitialized_fill_n_impl(ForwardIterator first, Count n, const T& value, true_type) + { + eastl::fill_n(first, n, value); + } + + template + void uninitialized_fill_n_impl(ForwardIterator first, Count n, const T& value, false_type) + { + typedef typename eastl::iterator_traits::value_type value_type; + ForwardIterator currentDest(first); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + for(; n > 0; --n, ++currentDest) + ::new(&*currentDest) value_type(value); + } + catch(...) + { + for(; first < currentDest; ++first) + first->~value_type(); + throw; + } + #else + for(; n > 0; --n, ++currentDest) + ::new(&*currentDest) value_type(value); + #endif + } + + /// uninitialized_fill_n + /// + /// Copy-constructs the range of [first, first + n) with the given input value. + /// Returns void as per the C++ standard, though returning the end input iterator + /// value may be of use. + /// + /// Declaration: + /// template + /// void uninitialized_fill_n(ForwardIterator destination, Count n, const T& value); + /// + template + inline void uninitialized_fill_n(ForwardIterator first, Count n, const T& value) + { + typedef typename eastl::iterator_traits::value_type value_type; + uninitialized_fill_n_impl(first, n, value, has_trivial_assign()); + } + + /// uninitialized_fill_n_ptr + /// + /// This is a specialization of uninitialized_fill_n for iterators that are pointers. + /// It exists so that we can declare a value_type for the iterator, which you + /// can't do with a pointer by itself. + /// + template + inline void uninitialized_fill_n_ptr(T* first, Count n, const T& value) + { + typedef typename eastl::iterator_traits >::value_type value_type; + uninitialized_fill_n_impl(generic_iterator(first), n, value, has_trivial_assign()); + } + + + + + /// uninitialized_copy_fill + /// + /// Copies [first1, last1) into [first2, first2 + (last1 - first1)) then + /// fills [first2 + (last1 - first1), last2) with value. + /// + template + inline void uninitialized_copy_fill(InputIterator first1, InputIterator last1, + ForwardIterator first2, ForwardIterator last2, const T& value) + { + const ForwardIterator mid(eastl::uninitialized_copy(first1, last1, first2)); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + eastl::uninitialized_fill(mid, last2, value); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + for(; first2 < mid; ++first2) + first2->~value_type(); + throw; + } + #endif + } + + + + + + /// uninitialized_fill_copy + /// + /// Fills [result, mid) with value then copies [first, last) into [mid, mid + (last - first)). + /// + template + inline ForwardIterator + uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid, const T& value, InputIterator first, InputIterator last) + { + eastl::uninitialized_fill(result, mid, value); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + return eastl::uninitialized_copy(first, last, mid); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + for(; result < mid; ++result) + result->~value_type(); + throw; + } + #endif + } + + + + /// uninitialized_copy_copy + /// + /// Copies [first1, last1) into [result, result + (last1 - first1)) then + /// copies [first2, last2) into [result, result + (last1 - first1) + (last2 - first2)). + /// + template + inline ForwardIterator + uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + ForwardIterator result) + { + const ForwardIterator mid(eastl::uninitialized_copy(first1, last1, result)); + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + return eastl::uninitialized_copy(first2, last2, mid); + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + for(; result < mid; ++result) + result->~value_type(); + throw; + } + #endif + } + + + + /// destruct + /// + /// Calls the destructor of a given object. + /// + /// Note that we don't have a specialized version of this for objects + /// with trivial destructors, such as integers. This is because the + /// compiler can already see in our version here that the destructor + /// is a no-op. + /// + template + inline void destruct(T* p) + { + p->~T(); + } + + + + // destruct(first, last) + // + template + inline void destruct_impl(ForwardIterator /*first*/, ForwardIterator /*last*/, true_type) // true means the type has a trivial destructor. + { + // Empty. The type has a trivial destructor. + } + + template + inline void destruct_impl(ForwardIterator first, ForwardIterator last, false_type) // false means the type has a significant destructor. + { + typedef typename eastl::iterator_traits::value_type value_type; + + for(; first != last; ++first) + (*first).~value_type(); + } + + /// destruct + /// + /// Calls the destructor on a range of objects. + /// + /// We have a specialization for objects with trivial destructors, such as + /// PODs. In this specialization the destruction of the range is a no-op. + /// + template + inline void destruct(ForwardIterator first, ForwardIterator last) + { + typedef typename eastl::iterator_traits::value_type value_type; + destruct_impl(first, last, eastl::has_trivial_destructor()); + } + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/set.h b/lib/eastl/include/EASTL/set.h new file mode 100644 index 0000000..72ce2e2 --- /dev/null +++ b/lib/eastl/include/EASTL/set.h @@ -0,0 +1,567 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/set.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written by Paul Pedriana. +////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_SET_H +#define EASTL_SET_H + + + +#include +#include +#include +#include + + + +namespace eastl +{ + + /// EASTL_SET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_SET_DEFAULT_NAME + #define EASTL_SET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " set" // Unless the user overrides something, this is "EASTL set". + #endif + + + /// EASTL_MULTISET_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_MULTISET_DEFAULT_NAME + #define EASTL_MULTISET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " multiset" // Unless the user overrides something, this is "EASTL multiset". + #endif + + + /// EASTL_SET_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_SET_DEFAULT_ALLOCATOR + #define EASTL_SET_DEFAULT_ALLOCATOR allocator_type(EASTL_SET_DEFAULT_NAME) + #endif + + /// EASTL_MULTISET_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_MULTISET_DEFAULT_ALLOCATOR + #define EASTL_MULTISET_DEFAULT_ALLOCATOR allocator_type(EASTL_MULTISET_DEFAULT_NAME) + #endif + + + + /// set + /// + /// Implements a canonical set. + /// + /// The large majority of the implementation of this class is found in the rbtree + /// base class. We control the behaviour of rbtree via template parameters. + /// + /// Note that the 'bMutableIterators' template parameter to rbtree is set to false. + /// This means that set::iterator is const and the same as set::const_iterator. + /// This is by design and it follows the C++ standard defect report recommendation. + /// If the user wants to modify a container element, the user needs to either use + /// mutable data members or use const_cast on the iterator's data member. Both of + /// these solutions are recommended by the C++ standard defect report. + /// To consider: Expose the bMutableIterators template policy here at the set level + /// so the user can have non-const set iterators via a template parameter. + /// + /// Pool allocation + /// If you want to make a custom memory pool for a set container, your pool + /// needs to contain items of type set::node_type. So if you have a memory + /// pool that has a constructor that takes the size of pool items and the + /// count of pool items, you would do this (assuming that MemoryPool implements + /// the Allocator interface): + /// typedef set, MemoryPool> WidgetSet; // Delare your WidgetSet type. + /// MemoryPool myPool(sizeof(WidgetSet::node_type), 100); // Make a pool of 100 Widget nodes. + /// WidgetSet mySet(&myPool); // Create a map that uses the pool. + /// + template , typename Allocator = EASTLAllocatorType> + class set + : public rbtree, false, true> + { + public: + typedef rbtree, false, true> base_type; + typedef set this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::allocator_type allocator_type; + // Other types are inherited from the base class. + + using base_type::begin; + using base_type::end; + using base_type::find; + using base_type::lower_bound; + using base_type::upper_bound; + using base_type::mCompare; + + public: + set(const allocator_type& allocator = EASTL_SET_DEFAULT_ALLOCATOR); + set(const Compare& compare, const allocator_type& allocator = EASTL_SET_DEFAULT_ALLOCATOR); + set(const this_type& x); + + template + set(Iterator itBegin, Iterator itEnd); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg. + + public: + size_type erase(const Key& k); + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + + size_type count(const Key& k) const; + + eastl::pair equal_range(const Key& k); + eastl::pair equal_range(const Key& k) const; + + }; // set + + + + + + /// multiset + /// + /// Implements a canonical multiset. + /// + /// The large majority of the implementation of this class is found in the rbtree + /// base class. We control the behaviour of rbtree via template parameters. + /// + /// See notes above in 'set' regarding multable iterators. + /// + /// Pool allocation + /// If you want to make a custom memory pool for a multiset container, your pool + /// needs to contain items of type multiset::node_type. So if you have a memory + /// pool that has a constructor that takes the size of pool items and the + /// count of pool items, you would do this (assuming that MemoryPool implements + /// the Allocator interface): + /// typedef multiset, MemoryPool> WidgetSet; // Delare your WidgetSet type. + /// MemoryPool myPool(sizeof(WidgetSet::node_type), 100); // Make a pool of 100 Widget nodes. + /// WidgetSet mySet(&myPool); // Create a map that uses the pool. + /// + template , typename Allocator = EASTLAllocatorType> + class multiset + : public rbtree, false, false> + { + public: + typedef rbtree, false, false> base_type; + typedef multiset this_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::allocator_type allocator_type; + // Other types are inherited from the base class. + + using base_type::begin; + using base_type::end; + using base_type::find; + using base_type::lower_bound; + using base_type::upper_bound; + using base_type::mCompare; + + public: + multiset(const allocator_type& allocator = EASTL_MULTISET_DEFAULT_ALLOCATOR); + multiset(const Compare& compare, const allocator_type& allocator = EASTL_MULTISET_DEFAULT_ALLOCATOR); + multiset(const this_type& x); + + template + multiset(Iterator itBegin, Iterator itEnd); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg. + + public: + size_type erase(const Key& k); + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + + size_type count(const Key& k) const; + + eastl::pair equal_range(const Key& k); + eastl::pair equal_range(const Key& k) const; + + /// equal_range_small + /// This is a special version of equal_range which is optimized for the + /// case of there being few or no duplicated keys in the tree. + eastl::pair equal_range_small(const Key& k); + eastl::pair equal_range_small(const Key& k) const; + + }; // multiset + + + + + + /////////////////////////////////////////////////////////////////////// + // set + /////////////////////////////////////////////////////////////////////// + + template + inline set::set(const allocator_type& allocator) + : base_type(allocator) + { + // Empty + } + + + template + inline set::set(const Compare& compare, const allocator_type& allocator) + : base_type(compare, allocator) + { + // Empty + } + + + template + inline set::set(const this_type& x) + : base_type(x) + { + // Empty + } + + + template + template + inline set::set(Iterator itBegin, Iterator itEnd) + : base_type(itBegin, itEnd, Compare(), EASTL_SET_DEFAULT_ALLOCATOR) + { + // Empty + } + + + template + inline typename set::size_type + set::erase(const Key& k) + { + const iterator it(find(k)); + + if(it != end()) // If it exists... + { + base_type::erase(it); + return 1; + } + return 0; + } + + + template + inline typename set::iterator + set::erase(iterator position) + { + // We need to provide this version because we override another version + // and C++ hiding rules would make the base version of this hidden. + return base_type::erase(position); + } + + + template + inline typename set::iterator + set::erase(iterator first, iterator last) + { + // We need to provide this version because we override another version + // and C++ hiding rules would make the base version of this hidden. + return base_type::erase(first, last); + } + + + template + inline typename set::size_type + set::count(const Key& k) const + { + const const_iterator it(find(k)); + return (it != end()) ? (size_type)1 : (size_type)0; + } + + + template + inline typename set::reverse_iterator + set::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + inline typename set::reverse_iterator + set::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + inline eastl::pair::iterator, + typename set::iterator> + set::equal_range(const Key& k) + { + // The resulting range will either be empty or have one element, + // so instead of doing two tree searches (one for lower_bound and + // one for upper_bound), we do just lower_bound and see if the + // result is a range of size zero or one. + const iterator itLower(lower_bound(k)); + + if((itLower == end()) || mCompare(k, *itLower)) // If at the end or if (k is < itLower)... + return eastl::pair(itLower, itLower); + + iterator itUpper(itLower); + return eastl::pair(itLower, ++itUpper); + } + + + template + inline eastl::pair::const_iterator, + typename set::const_iterator> + set::equal_range(const Key& k) const + { + // See equal_range above for comments. + const const_iterator itLower(lower_bound(k)); + + if((itLower == end()) || mCompare(k, *itLower)) // If at the end or if (k is < itLower)... + return eastl::pair(itLower, itLower); + + const_iterator itUpper(itLower); + return eastl::pair(itLower, ++itUpper); + } + + + + + + /////////////////////////////////////////////////////////////////////// + // multiset + /////////////////////////////////////////////////////////////////////// + + template + inline multiset::multiset(const allocator_type& allocator) + : base_type(allocator) + { + // Empty + } + + + template + inline multiset::multiset(const Compare& compare, const allocator_type& allocator) + : base_type(compare, allocator) + { + // Empty + } + + + template + inline multiset::multiset(const this_type& x) + : base_type(x) + { + // Empty + } + + + template + template + inline multiset::multiset(Iterator itBegin, Iterator itEnd) + : base_type(itBegin, itEnd, Compare(), EASTL_MULTISET_DEFAULT_ALLOCATOR) + { + // Empty + } + + + template + inline typename multiset::size_type + multiset::erase(const Key& k) + { + const eastl::pair range(equal_range(k)); + const size_type n = (size_type)eastl::distance(range.first, range.second); + base_type::erase(range.first, range.second); + return n; + } + + + template + inline typename multiset::iterator + multiset::erase(iterator position) + { + // We need to provide this version because we override another version + // and C++ hiding rules would make the base version of this hidden. + return base_type::erase(position); + } + + + template + inline typename multiset::iterator + multiset::erase(iterator first, iterator last) + { + // We need to provide this version because we override another version + // and C++ hiding rules would make the base version of this hidden. + return base_type::erase(first, last); + } + + + template + inline typename multiset::size_type + multiset::count(const Key& k) const + { + const eastl::pair range(equal_range(k)); + return (size_type)eastl::distance(range.first, range.second); + } + + + template + inline typename multiset::reverse_iterator + multiset::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + inline typename multiset::reverse_iterator + multiset::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + inline eastl::pair::iterator, + typename multiset::iterator> + multiset::equal_range(const Key& k) + { + // There are multiple ways to implement equal_range. The implementation mentioned + // in the C++ standard and which is used by most (all?) commercial STL implementations + // is this: + // return eastl::pair(lower_bound(k), upper_bound(k)); + // + // This does two tree searches -- one for the lower bound and one for the + // upper bound. This works well for the case whereby you have a large container + // and there are lots of duplicated values. We provide an alternative version + // of equal_range called equal_range_small for cases where the user is confident + // that the number of duplicated items is only a few. + + return eastl::pair(lower_bound(k), upper_bound(k)); + } + + + template + inline eastl::pair::const_iterator, + typename multiset::const_iterator> + multiset::equal_range(const Key& k) const + { + // See comments above in the non-const version of equal_range. + return eastl::pair(lower_bound(k), upper_bound(k)); + } + + + template + inline eastl::pair::iterator, + typename multiset::iterator> + multiset::equal_range_small(const Key& k) + { + // We provide alternative version of equal_range here which works faster + // for the case where there are at most small number of potential duplicated keys. + const iterator itLower(lower_bound(k)); + iterator itUpper(itLower); + + while((itUpper != end()) && !mCompare(k, itUpper.mpNode->mValue)) + ++itUpper; + + return eastl::pair(itLower, itUpper); + } + + + template + inline eastl::pair::const_iterator, + typename multiset::const_iterator> + multiset::equal_range_small(const Key& k) const + { + // We provide alternative version of equal_range here which works faster + // for the case where there are at most small number of potential duplicated keys. + const const_iterator itLower(lower_bound(k)); + const_iterator itUpper(itLower); + + while((itUpper != end()) && !mCompare(k, *itUpper)) + ++itUpper; + + return eastl::pair(itLower, itUpper); + } + + + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/sort.h b/lib/eastl/include/EASTL/sort.h new file mode 100644 index 0000000..4d77466 --- /dev/null +++ b/lib/eastl/include/EASTL/sort.h @@ -0,0 +1,912 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/sort.h +// Written by Paul Pedriana - 2005. +////////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////////// +// This file implements sorting algorithms. Some of these are equivalent to +// std C++ sorting algorithms, while others don't have equivalents in the +// C++ standard. We implement the following sorting algorithms: +// is_sorted +// sort The implementation of this is simply mapped to quick_sort. +// quick_sort +// partial_sort +// insertion_sort +// shell_sort +// heap_sort +// stable_sort The implementation of this is simply mapped to merge_sort. +// merge +// merge_sort +// merge_sort_buffer +// nth_element +// radix_sort Found in sort_extra.h. +// comb_sort Found in sort_extra.h. +// bubble_sort Found in sort_extra.h. +// selection_sort Found in sort_extra.h. +// shaker_sort Found in sort_extra.h. +// bucket_sort Found in sort_extra.h. +// +// Additional sorting and related algorithms we may want to implement: +// partial_sort_copy This would be like the std STL version. +// paritition This would be like the std STL version. This is not categorized as a sort routine by the language standard. +// stable_partition This would be like the std STL version. +// counting_sort Maybe we don't want to implement this. +// +////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_SORT_H +#define EASTL_SORT_H + + + +#include +#include +#include +#include +#include +#include +#include +#include + + + +namespace eastl +{ + + /// is_sorted + /// + /// Returns true if the range [first, last) is sorted. + /// An empty range is considered to be sorted. + /// To test if a range is reverse-sorted, use 'greater' as the comparison + /// instead of 'less'. + /// + /// Example usage: + /// vector intArray; + /// bool bIsSorted = is_sorted(intArray.begin(), intArray.end()); + /// bool bIsReverseSorted = is_sorted(intArray.begin(), intArray.end(), greater()); + /// + template + bool is_sorted(ForwardIterator first, ForwardIterator last, StrictWeakOrdering compare) + { + if(first != last) + { + ForwardIterator current = first; + + for(++current; current != last; first = current, ++current) + { + if(compare(*current, *first)) + { + EASTL_VALIDATE_COMPARE(!compare(*first, *current)); // Validate that the compare function is sane. + return false; + } + } + } + return true; + } + + template + inline bool is_sorted(ForwardIterator first, ForwardIterator last) + { + typedef eastl::less::value_type> Less; + + return eastl::is_sorted(first, last, Less()); + } + + + + /// merge + /// + /// This function merges two sorted input sorted ranges into a result sorted range. + /// This merge is stable in that no element from the first range will be changed + /// in order relative to other elements from the first range. + /// + template + OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare) + { + while((first1 != last1) && (first2 != last2)) + { + if(compare(*first2, *first1)) + { + EASTL_VALIDATE_COMPARE(!compare(*first1, *first2)); // Validate that the compare function is sane. + *result = *first2; + ++first2; + } + else + { + *result = *first1; + ++first1; + } + ++result; + } + + return eastl::copy(first2, last2, eastl::copy(first1, last1, result)); + } + + template + inline OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result) + { + typedef eastl::less::value_type> Less; + + return eastl::merge + (first1, last1, first2, last2, result, Less()); + } + + + + /// insertion_sort + /// + /// Implements the InsertionSort algorithm. + /// + template + void insertion_sort(BidirectionalIterator first, BidirectionalIterator last, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::value_type value_type; + + if(first != last) + { + BidirectionalIterator iCurrent, iNext, iSorted = first; + + for(++iSorted; iSorted != last; ++iSorted) + { + const value_type temp(*iSorted); + + iNext = iCurrent = iSorted; + + for(--iCurrent; (iNext != first) && compare(temp, *iCurrent); --iNext, --iCurrent) + { + EASTL_VALIDATE_COMPARE(!compare(*iCurrent, temp)); // Validate that the compare function is sane. + *iNext = *iCurrent; + } + + *iNext = temp; + } + } + } // insertion_sort + + + + template + void insertion_sort(BidirectionalIterator first, BidirectionalIterator last) + { + typedef typename eastl::iterator_traits::value_type value_type; + + if(first != last) + { + BidirectionalIterator iCurrent, iNext, iSorted = first; + + for(++iSorted; iSorted != last; ++iSorted) + { + const value_type temp(*iSorted); + + iNext = iCurrent = iSorted; + + for(--iCurrent; (iNext != first) && (temp < *iCurrent); --iNext, --iCurrent) + { + EASTL_VALIDATE_COMPARE(!(*iCurrent < temp)); // Validate that the compare function is sane. + *iNext = *iCurrent; + } + + *iNext = temp; + } + } + } // insertion_sort + + + #if 0 /* + // STLPort-like variation of insertion_sort. Doesn't seem to run quite as fast for small runs. + // + template + void insertion_sort(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + if(first != last) + { + for(RandomAccessIterator i = first + 1; i != last; ++i) + { + const typename eastl::iterator_traits::value_type value(*i); + + if(compare(value, *first)) + { + EASTL_VALIDATE_COMPARE(!compare(*first, value)); // Validate that the compare function is sane. + eastl::copy_backward(first, i, i + 1); + *first = value; + } + else + { + RandomAccessIterator end(i), prev(i); + + for(--prev; compare(value, *prev); --end, --prev) + { + EASTL_VALIDATE_COMPARE(!compare(*prev, value)); // Validate that the compare function is sane. + *end = *prev; + } + + *end = value; + } + } + } + } + + + // STLPort-like variation of insertion_sort. Doesn't seem to run quite as fast for small runs. + // + template + void insertion_sort(RandomAccessIterator first, RandomAccessIterator last) + { + if(first != last) + { + for(RandomAccessIterator i = first + 1; i != last; ++i) + { + const typename eastl::iterator_traits::value_type value(*i); + + if(value < *first) + { + EASTL_VALIDATE_COMPARE(!(*first < value)); // Validate that the compare function is sane. + eastl::copy_backward(first, i, i + 1); + *first = value; + } + else + { + RandomAccessIterator end(i), prev(i); + + for(--prev; value < *prev; --end, --prev) + { + EASTL_VALIDATE_COMPARE(!(*prev < value)); // Validate that the compare function is sane. + *end = *prev; + } + + *end = value; + } + } + } + } */ + #endif + + + /// shell_sort + /// + /// Implements the ShellSort algorithm. This algorithm is a serious algorithm for larger + /// data sets, as reported by Sedgewick in his discussions on QuickSort. Note that shell_sort + /// requires a random access iterator, which usually means an array (eg. vector, deque). + /// ShellSort has good performance with presorted sequences. + /// The term "shell" derives from the name of the inventor, David Shell. + /// + /// To consider: Allow the user to specify the "h-sequence" array. + /// + template + void shell_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + + // We use the Knuth 'h' sequence below, as it is easy to calculate at runtime. + // However, possibly we are better off using a different sequence based on a table. + // One such sequence which averages slightly better than Knuth is: + // 1, 5, 19, 41, 109, 209, 505, 929, 2161, 3905, 8929, 16001, 36289, + // 64769, 146305, 260609, 587521, 1045505, 2354689, 4188161, 9427969, 16764929 + + if(first != last) + { + RandomAccessIterator iCurrent, iBack, iSorted, iInsertFirst; + difference_type nSize = last - first; + difference_type nSpace = 1; // nSpace is the 'h' value of the ShellSort algorithm. + + while(nSpace < nSize) + nSpace = (nSpace * 3) + 1; // This is the Knuth 'h' sequence: 1, 4, 13, 40, 121, 364, 1093, 3280, 9841, 29524, 88573, 265720, 797161, 2391484, 7174453, 21523360, 64570081, 193710244, + + for(nSpace = (nSpace - 1) / 3; nSpace >= 1; nSpace = (nSpace - 1) / 3) // Integer division is less than ideal. + { + for(difference_type i = 0; i < nSpace; i++) + { + iInsertFirst = first + i; + + for(iSorted = iInsertFirst + nSpace; iSorted < last; iSorted += nSpace) + { + iBack = iCurrent = iSorted; + + for(iBack -= nSpace; (iCurrent != iInsertFirst) && compare(*iCurrent, *iBack); iCurrent = iBack, iBack -= nSpace) + { + EASTL_VALIDATE_COMPARE(!compare(*iBack, *iCurrent)); // Validate that the compare function is sane. + eastl::iter_swap(iCurrent, iBack); + } + } + } + } + } + } // shell_sort + + template + inline void shell_sort(RandomAccessIterator first, RandomAccessIterator last) + { + typedef eastl::less::value_type> Less; + + eastl::shell_sort(first, last, Less()); + } + + + + /// heap_sort + /// + /// Implements the HeapSort algorithm. + /// Note that heap_sort requires a random access iterator, which usually means + /// an array (eg. vector, deque). + /// + template + void heap_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering compare) + { + // We simply call our heap algorithms to do the work for us. + eastl::make_heap(first, last, compare); + eastl::sort_heap(first, last, compare); + } + + template + inline void heap_sort(RandomAccessIterator first, RandomAccessIterator last) + { + typedef eastl::less::value_type> Less; + + eastl::heap_sort(first, last, Less()); + } + + + + + /// merge_sort_buffer + /// + /// Implements the MergeSort algorithm with a user-supplied buffer. + /// The input buffer must be able to hold a number of items equal to 'last - first'. + /// Note that merge_sort_buffer requires a random access iterator, which usually means + /// an array (eg. vector, deque). + /// + + // For reference, the following is the simple version, before inlining one level + // of recursion and eliminating the copy: + // + //template + //void merge_sort_buffer(RandomAccessIterator first, RandomAccessIterator last, T* pBuffer, StrictWeakOrdering compare) + //{ + // typedef typename eastl::iterator_traits::difference_type difference_type; + // + // const difference_type nCount = last - first; + // + // if(nCount > 1) + // { + // const difference_type nMid = nCount / 2; + // + // eastl::merge_sort_buffer + // (first, first + nMid, pBuffer, compare); + // eastl::merge_sort_buffer + // (first + nMid, last , pBuffer, compare); + // eastl::copy(first, last, pBuffer); + // eastl::merge + // (pBuffer, pBuffer + nMid, pBuffer + nMid, pBuffer + nCount, first, compare); + // } + //} + + template + void merge_sort_buffer(RandomAccessIterator first, RandomAccessIterator last, T* pBuffer, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + const difference_type nCount = last - first; + + if(nCount > 1) + { + const difference_type nMid = nCount / 2; + RandomAccessIterator half = first + nMid; + + if(nMid > 1) + { + const difference_type nQ1(nMid / 2); + RandomAccessIterator part(first + nQ1); + + eastl::merge_sort_buffer(first, part, pBuffer, compare); + eastl::merge_sort_buffer(part, half, pBuffer + nQ1, compare); + eastl::merge + (first, part, part, half, pBuffer, compare); + } + else + *pBuffer = *first; + + if((nCount - nMid) > 1) + { + const difference_type nQ3((nMid + nCount) / 2); + RandomAccessIterator part(first + nQ3); + + eastl::merge_sort_buffer(half, part, pBuffer + nMid, compare); + eastl::merge_sort_buffer(part, last, pBuffer + nQ3, compare); + eastl::merge + (half, part, part, last, pBuffer + nMid, compare); + } + else + *(pBuffer + nMid) = *half; + + eastl::merge + (pBuffer, pBuffer + nMid, pBuffer + nMid, pBuffer + nCount, first, compare); + } + } + + template + inline void merge_sort_buffer(RandomAccessIterator first, RandomAccessIterator last, T* pBuffer) + { + typedef eastl::less::value_type> Less; + + eastl::merge_sort_buffer(first, last, pBuffer, Less()); + } + + + + /// merge_sort + /// + /// Implements the MergeSort algorithm. + /// This algorithm allocates memory via the user-supplied allocator. Use merge_sort_buffer + /// function if you want a version which doesn't allocate memory. + /// Note that merge_sort requires a random access iterator, which usually means + /// an array (eg. vector, deque). + /// + template + void merge_sort(RandomAccessIterator first, RandomAccessIterator last, Allocator& allocator, StrictWeakOrdering compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + const difference_type nCount = last - first; + + if(nCount > 1) + { + // We need to allocate an array of nCount value_type objects as a temporary buffer. + value_type* const pBuffer = (value_type*)allocate_memory(allocator, nCount * sizeof(value_type), EASTL_ALIGN_OF(value_type), 0); + eastl::uninitialized_fill(pBuffer, pBuffer + nCount, value_type()); + + eastl::merge_sort_buffer + (first, last, pBuffer, compare); + + eastl::destruct(pBuffer, pBuffer + nCount); + EASTLFree(allocator, pBuffer, nCount * sizeof(value_type)); + } + } + + template + inline void merge_sort(RandomAccessIterator first, RandomAccessIterator last, Allocator& allocator) + { + typedef eastl::less::value_type> Less; + + eastl::merge_sort(first, last, allocator, Less()); + } + + + + ///////////////////////////////////////////////////////////////////// + // quick_sort + // + // We do the "introspection sort" variant of quick sort which is now + // well-known and understood. You can read about this algorithm in + // many articles on quick sort, but briefly what it does is a median- + // of-three quick sort whereby the recursion depth is limited to a + // some value (after which it gives up on quick sort and switches to + // a heap sort) and whereby after a certain amount of sorting the + // algorithm stops doing quick-sort and finishes the sorting via + // a simple insertion sort. + ///////////////////////////////////////////////////////////////////// + + static const int kQuickSortLimit = 28; // For sorts of random arrays over 100 items, 28 - 32 have been found to be good numbers on VC++/Win32. + + namespace Internal + { + template + inline Size Log2(Size n) + { + int i; + for(i = 0; n; ++i) + n >>= 1; + return i - 1; + } + + // To do: Investigate the speed of this bit-trick version of Log2. + // It may work better on some platforms but not others. + // + // union FloatUnion { + // float f; + // uint32_t i; + // }; + // + // inline uint32_t Log2(uint32_t x) + // { + // const FloatInt32Union u = { x }; + // return (u.i >> 23) - 127; + // } + } + + + /// get_partition + /// + /// This function takes const T& instead of T because T may have special alignment + /// requirements and some compilers (e.g. VC++) are don't respect alignment requirements + /// for function arguments. + /// + template + inline RandomAccessIterator get_partition(RandomAccessIterator first, RandomAccessIterator last, const T& pivotValue) + { + const T pivotCopy(pivotValue); // Need to make a temporary because the sequence below is mutating. + + for(; ; ++first) + { + while(*first < pivotCopy) + { + EASTL_VALIDATE_COMPARE(!(pivotCopy < *first)); // Validate that the compare function is sane. + ++first; + } + --last; + + while(pivotCopy < *last) + { + EASTL_VALIDATE_COMPARE(!(*last < pivotCopy)); // Validate that the compare function is sane. + --last; + } + + if(first >= last) // Random access iterators allow operator >= + return first; + + eastl::iter_swap(first, last); + } + } + + + template + inline RandomAccessIterator get_partition(RandomAccessIterator first, RandomAccessIterator last, const T& pivotValue, Compare compare) + { + const T pivotCopy(pivotValue); // Need to make a temporary because the sequence below is mutating. + + for(; ; ++first) + { + while(compare(*first, pivotCopy)) + { + EASTL_VALIDATE_COMPARE(!compare(pivotCopy, *first)); // Validate that the compare function is sane. + ++first; + } + --last; + + while(compare(pivotCopy, *last)) + { + EASTL_VALIDATE_COMPARE(!compare(*last, pivotCopy)); // Validate that the compare function is sane. + --last; + } + + if(first >= last) // Random access iterators allow operator >= + return first; + + eastl::iter_swap(first, last); + } + } + + + namespace Internal + { + // This function is used by quick_sort and is not intended to be used by itself. + // This is because the implementation below makes an assumption about the input + // data that quick_sort satisfies but arbitrary data may not. + // There is a standalone insertion_sort function. + template + inline void insertion_sort_simple(RandomAccessIterator first, RandomAccessIterator last) + { + for(RandomAccessIterator current = first; current != last; ++current) + { + typedef typename eastl::iterator_traits::value_type value_type; + + RandomAccessIterator end(current), prev(current); + const value_type value(*current); + + for(--prev; value < *prev; --end, --prev) // We skip checking for (prev >= first) because quick_sort (our caller) makes this unnecessary. + { + EASTL_VALIDATE_COMPARE(!(*prev < value)); // Validate that the compare function is sane. + *end = *prev; + } + + *end = value; + } + } + + + // This function is used by quick_sort and is not intended to be used by itself. + // This is because the implementation below makes an assumption about the input + // data that quick_sort satisfies but arbitrary data may not. + // There is a standalone insertion_sort function. + template + inline void insertion_sort_simple(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + for(RandomAccessIterator current = first; current != last; ++current) + { + typedef typename eastl::iterator_traits::value_type value_type; + + RandomAccessIterator end(current), prev(current); + const value_type value(*current); + + for(--prev; compare(value, *prev); --end, --prev) // We skip checking for (prev >= first) because quick_sort (our caller) makes this unnecessary. + { + EASTL_VALIDATE_COMPARE(!compare(*prev, value)); // Validate that the compare function is sane. + *end = *prev; + } + + *end = value; + } + } + } // namespace Internal + + + template + inline void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + eastl::make_heap(first, middle); + + for(RandomAccessIterator i = middle; i < last; ++i) + { + if(*i < *first) + { + EASTL_VALIDATE_COMPARE(!(*first < *i)); // Validate that the compare function is sane. + const value_type temp(*i); + *i = *first; + eastl::adjust_heap + (first, difference_type(0), difference_type(middle - first), difference_type(0), temp); + } + } + + eastl::sort_heap(first, middle); + } + + + template + inline void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + typedef typename eastl::iterator_traits::value_type value_type; + + eastl::make_heap(first, middle, compare); + + for(RandomAccessIterator i = middle; i < last; ++i) + { + if(compare(*i, *first)) + { + EASTL_VALIDATE_COMPARE(!compare(*first, *i)); // Validate that the compare function is sane. + const value_type temp(*i); + *i = *first; + eastl::adjust_heap + (first, difference_type(0), difference_type(middle - first), difference_type(0), temp, compare); + } + } + + eastl::sort_heap(first, middle, compare); + } + + + template + inline void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last) + { + typedef typename iterator_traits::value_type value_type; + + while((last - first) > 5) + { + const value_type midValue(eastl::median(*first, *(first + (last - first) / 2), *(last - 1))); + const RandomAccessIterator midPos(eastl::get_partition(first, last, midValue)); + + if(midPos <= nth) + first = midPos; + else + last = midPos; + } + + eastl::insertion_sort(first, last); + } + + + template + inline void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare compare) + { + typedef typename iterator_traits::value_type value_type; + + while((last - first) > 5) + { + const value_type midValue(eastl::median(*first, *(first + (last - first) / 2), *(last - 1), compare)); + const RandomAccessIterator midPos(eastl::get_partition(first, last, midValue, compare)); + + if(midPos <= nth) + first = midPos; + else + last = midPos; + } + + eastl::insertion_sort(first, last, compare); + } + + + template + inline void quick_sort_impl(RandomAccessIterator first, RandomAccessIterator last, Size kRecursionCount) + { + typedef typename iterator_traits::value_type value_type; + + while(((last - first) > kQuickSortLimit) && (kRecursionCount > 0)) + { + const RandomAccessIterator position(eastl::get_partition(first, last, eastl::median(*first, *(first + (last - first) / 2), *(last - 1)))); + + eastl::quick_sort_impl(position, last, --kRecursionCount); + last = position; + } + + if(kRecursionCount == 0) + eastl::partial_sort(first, last, last); + } + + + template + inline void quick_sort_impl(RandomAccessIterator first, RandomAccessIterator last, Size kRecursionCount, Compare compare) + { + typedef typename iterator_traits::value_type value_type; + + while(((last - first) > kQuickSortLimit) && (kRecursionCount > 0)) + { + const RandomAccessIterator position(eastl::get_partition(first, last, eastl::median(*first, *(first + (last - first) / 2), *(last - 1), compare), compare)); + + eastl::quick_sort_impl(position, last, --kRecursionCount, compare); + last = position; + } + + if(kRecursionCount == 0) + eastl::partial_sort(first, last, last, compare); + } + + + /// quick_sort + /// + /// quick_sort sorts the elements in [first, last) into ascending order, + /// meaning that if i and j are any two valid iterators in [first, last) + /// such that i precedes j, then *j is not less than *i. quick_sort is not + /// guaranteed to be stable. That is, suppose that *i and *j are equivalent: + /// neither one is less than the other. It is not guaranteed that the + /// relative order of these two elements will be preserved by sort. + /// + /// We implement the "introspective" variation of quick-sort. This is + /// considered to be the best general-purpose variant, as it avoids + /// worst-case behaviour and optimizes the final sorting stage by + /// switching to an insertion sort. + /// + template + void quick_sort(RandomAccessIterator first, RandomAccessIterator last) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + + if(first != last) + { + eastl::quick_sort_impl(first, last, 2 * Internal::Log2(last - first)); + + if((last - first) > (difference_type)kQuickSortLimit) + { + eastl::insertion_sort(first, first + kQuickSortLimit); + eastl::Internal::insertion_sort_simple(first + kQuickSortLimit, last); + } + else + eastl::insertion_sort(first, last); + } + } + + + template + void quick_sort(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + typedef typename eastl::iterator_traits::difference_type difference_type; + + if(first != last) + { + eastl::quick_sort_impl(first, last, 2 * Internal::Log2(last - first), compare); + + if((last - first) > (difference_type)kQuickSortLimit) + { + eastl::insertion_sort(first, first + kQuickSortLimit, compare); + eastl::Internal::insertion_sort_simple(first + kQuickSortLimit, last, compare); + } + else + eastl::insertion_sort(first, last, compare); + } + } + + + + /// sort + /// + /// We simply use quick_sort. See quick_sort for details. + /// + template + inline void sort(RandomAccessIterator first, RandomAccessIterator last) + { + eastl::quick_sort(first, last); + } + + template + inline void sort(RandomAccessIterator first, RandomAccessIterator last, Compare compare) + { + eastl::quick_sort(first, last, compare); + } + + + + /// stable_sort + /// + /// We simply use merge_sort. See merge_sort for details. + /// Beware that the used merge_sort -- and thus stable_sort -- allocates + /// memory during execution. Try using merge_sort_buffer if you want + /// to avoid memory allocation. + /// + template + void stable_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering compare) + { + eastl::merge_sort + (first, last, *get_default_allocator(0), compare); + } + + template + void stable_sort(RandomAccessIterator first, RandomAccessIterator last) + { + eastl::merge_sort + (first, last, *get_default_allocator(0)); + } + + template + void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Allocator& allocator, StrictWeakOrdering compare) + { + eastl::merge_sort(first, last, allocator, compare); + } + + // This is not defined because it would cause compiler errors due to conflicts with a version above. + //template + //void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Allocator& allocator) + //{ + // eastl::merge_sort(first, last, allocator); + //} + +} // namespace eastl + + +#endif // Header include guard + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/string.h b/lib/eastl/include/EASTL/string.h new file mode 100644 index 0000000..bdf4410 --- /dev/null +++ b/lib/eastl/include/EASTL/string.h @@ -0,0 +1,3496 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/string.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Implements a basic_string class, much like the C++ std::basic_string. +// The primary distinctions between basic_string and std::basic_string are: +// - basic_string has a few extension functions that allow for increased performance. +// - basic_string has a few extension functions that make use easier, +// such as a member sprintf function and member tolower/toupper functions. +// - basic_string supports debug memory naming natively. +// - basic_string is easier to read, debug, and visualize. +// - basic_string internally manually expands basic functions such as begin(), +// size(), etc. in order to improve debug performance and optimizer success. +// - basic_string is savvy to an environment that doesn't have exception handling, +// as is sometimes the case with console or embedded environments. +// - basic_string has less deeply nested function calls and allows the user to +// enable forced inlining in debug builds in order to reduce bloat. +// - basic_string doesn't use char traits. As a result, EASTL assumes that +// strings will hold characters and not exotic things like widgets. At the +// very least, basic_string assumes that the value_type is a POD. +// - basic_string::size_type is defined as eastl_size_t instead of size_t in +// order to save memory and run faster on 64 bit systems. +// - basic_string data is guaranteed to be contiguous. +// - basic_string data is guaranteed to be 0-terminated, and the c_str() function +// is guaranteed to return the same pointer as the data() which is guaranteed +// to be the same value as &string[0]. +// - basic_string has a set_capacity() function which frees excess capacity. +// The only way to do this with std::basic_string is via the cryptic non-obvious +// trick of using: basic_string(x).swap(x); +// - basic_string has a force_size() function, which unilaterally moves the string +// end position (mpEnd) to the given location. Useful for when the user writes +// into the string via some extenal means such as C strcpy or sprintf. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Copy on Write (cow) +// +// This string implementation does not do copy on write (cow). This is by design, +// as cow penalizes 95% of string uses for the benefit of only 5% of the uses +// (these percentages are qualitative, not quantitative). The primary benefit of +// cow is that it allows for the sharing of string data between two string objects. +// Thus if you say this: +// string a("hello"); +// string b(a); +// the "hello" will be shared between a and b. If you then say this: +// a = "world"; +// then a will release its reference to "hello" and leave b with the only reference +// to it. Normally this functionality is accomplished via reference counting and +// with atomic operations or mutexes. +// +// The C++ standard does not say anything about basic_string and cow. However, +// for a basic_string implementation to be standards-conforming, a number of +// issues arise which dictate some things about how one would have to implement +// a cow string. The discussion of these issues will not be rehashed here, as you +// can read the references below for better detail than can be provided in the +// space we have here. However, we can say that the C++ standard is sensible and +// that anything we try to do here to allow for an efficient cow implementation +// would result in a generally unacceptable string interface. +// +// The disadvantages of cow strings are: +// - A reference count needs to exist with the string, which increases string memory usage. +// - With thread safety, atomic operations and mutex locks are expensive, especially +// on weaker memory systems such as console gaming platforms. +// - All non-const string accessor functions need to do a sharing check the the +// first such check needs to detach the string. Similarly, all string assignments +// need to do a sharing check as well. If you access the string before doing an +// assignment, the assignment doesn't result in a shared string, because the string +// has already been detached. +// - String sharing doesn't happen the large majority of the time. In some cases, +// the total sum of the reference count memory can exceed any memory savings +// gained by the strings that share representations. +// +// The addition of a string_cow class is under consideration for this library. +// There are conceivably some systems which have string usage patterns which would +// benefit from cow sharing. Such functionality is best saved for a separate string +// implementation so that the other string uses aren't penalized. +// +// References: +// This is a good starting HTML reference on the topic: +// http://www.gotw.ca/publications/optimizations.htm +// Here is a Usenet discussion on the topic: +// http://groups-beta.google.com/group/comp.lang.c++.moderated/browse_thread/thread/3dc6af5198d0bf7/886c8642cb06e03d +// +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_STRING_H +#define EASTL_STRING_H + + +#include +#if EASTL_ABSTRACT_STRING_ENABLED + #include +#else // 'else' encompasses the entire rest of this file. +#include +#include +#include +#ifdef __clang__ + #include +#endif + +#ifdef _MSC_VER + #pragma warning(push, 0) +#endif +#include // size_t, ptrdiff_t, etc. +#include // vararg functionality. +#include // malloc, free. +#include // snprintf, etc. +#include // toupper, etc. +#include // toupper, etc. +#ifdef __MWERKS__ + #include <../Include/string.h> // Force the compiler to use the std lib header. +#else + #include // strlen, etc. +#endif +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +#if EASTL_EXCEPTIONS_ENABLED + #ifdef _MSC_VER + #pragma warning(push, 0) + #endif + #include // std::out_of_range, std::length_error. + #ifdef _MSC_VER + #pragma warning(pop) + #endif +#endif + +#ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc + #pragma warning(disable: 4267) // 'argument' : conversion from 'size_t' to 'const uint32_t', possible loss of data. This is a bogus warning resulting from a bug in VC++. + #pragma warning(disable: 4480) // nonstandard extension used: specifying underlying type for enum +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_STRING_EXPLICIT +// +// See EASTL_STRING_OPT_EXPLICIT_CTORS for documentation. +// +#if EASTL_STRING_OPT_EXPLICIT_CTORS + #define EASTL_STRING_EXPLICIT explicit +#else + #define EASTL_STRING_EXPLICIT +#endif +/////////////////////////////////////////////////////////////////////////////// + + + +/////////////////////////////////////////////////////////////////////////////// +// EASTL_STRING_INITIAL_CAPACITY +// +// As of this writing, this must be > 0. Note that an initially empty string +// has a capacity of zero (it allocates no memory). +// +const eastl_size_t EASTL_STRING_INITIAL_CAPACITY = 8; +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Vsnprintf8 / Vsnprintf16 +// +// The user is expected to supply these functions. Note that these functions +// are expected to accept parameters as per the C99 standard. These functions +// can deal with C99 standard return values or Microsoft non-standard return +// values but act more efficiently if implemented via the C99 style. + +extern int Vsnprintf8 (char8_t* pDestination, size_t n, const char8_t* pFormat, va_list arguments); +extern int Vsnprintf16(char16_t* pDestination, size_t n, const char16_t* pFormat, va_list arguments); +extern int Vsnprintf32(char32_t* pDestination, size_t n, const char32_t* pFormat, va_list arguments); + +namespace eastl +{ + inline int Vsnprintf(char8_t* pDestination, size_t n, const char8_t* pFormat, va_list arguments) + { return Vsnprintf8(pDestination, n, pFormat, arguments); } + + inline int Vsnprintf(char16_t* pDestination, size_t n, const char16_t* pFormat, va_list arguments) + { return Vsnprintf16(pDestination, n, pFormat, arguments); } + + inline int Vsnprintf(char32_t* pDestination, size_t n, const char32_t* pFormat, va_list arguments) + { return Vsnprintf32(pDestination, n, pFormat, arguments); } +} +/////////////////////////////////////////////////////////////////////////////// + + + +namespace eastl +{ + + /// EASTL_BASIC_STRING_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// + #ifndef EASTL_BASIC_STRING_DEFAULT_NAME + #define EASTL_BASIC_STRING_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " basic_string" // Unless the user overrides something, this is "EASTL basic_string". + #endif + + + /// EASTL_BASIC_STRING_DEFAULT_ALLOCATOR + /// + #ifndef EASTL_BASIC_STRING_DEFAULT_ALLOCATOR + #define EASTL_BASIC_STRING_DEFAULT_ALLOCATOR allocator_type(EASTL_BASIC_STRING_DEFAULT_NAME) + #endif + + + + /// gEmptyString + /// + /// Declares a shared terminating 0 representation for scalar strings that are empty. + /// + union EmptyString + { + uint32_t mUint32; + char mEmpty8[1]; + unsigned char mEmptyU8[1]; + signed char mEmptyS8[1]; + char16_t mEmpty16[1]; + char32_t mEmpty32[1]; + }; + extern EASTL_API EmptyString gEmptyString; + + inline const signed char* GetEmptyString(signed char) { return gEmptyString.mEmptyS8; } + inline const unsigned char* GetEmptyString(unsigned char) { return gEmptyString.mEmptyU8; } + inline const char* GetEmptyString(char) { return gEmptyString.mEmpty8; } + inline const char16_t* GetEmptyString(char16_t) { return gEmptyString.mEmpty16; } + inline const char32_t* GetEmptyString(char32_t) { return gEmptyString.mEmpty32; } + + + /////////////////////////////////////////////////////////////////////////////// + /// basic_string + /// + /// Implements a templated string class, somewhat like C++ std::basic_string. + /// + /// Notes: + /// As of this writing, an insert of a string into itself necessarily + /// triggers a reallocation, even if there is enough capacity in self + /// to handle the increase in size. This is due to the slightly tricky + /// nature of the operation of modifying one's self with one's self, + /// and thus the source and destination are being modified during the + /// operation. It might be useful to rectify this to the extent possible. + /// + template + class basic_string + { + public: + typedef basic_string this_type; + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef T* iterator; // Maintainer note: We want to leave iterator defined as T* -- at least in release builds -- as this gives some algorithms an advantage that optimizers cannot get around. + typedef const T* const_iterator; + typedef eastl::reverse_iterator reverse_iterator; + typedef eastl::reverse_iterator const_reverse_iterator; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef ptrdiff_t difference_type; + typedef Allocator allocator_type; + + #if defined(_MSC_VER) && (_MSC_VER >= 1400) // _MSC_VER of 1400 means VC8 (VS2005), 1500 means VC9 (VS2008) + enum : size_type { // Use Microsoft enum language extension, allowing for smaller debug symbols than using a static const. Users have been affected by this. + npos = (size_type)-1, + kMaxSize = (size_type)-2 + }; + #else + static const size_type npos = (size_type)-1; /// 'npos' means non-valid position or simply non-position. + static const size_type kMaxSize = (size_type)-2; /// -1 is reserved for 'npos'. It also happens to be slightly beneficial that kMaxSize is a value less than -1, as it helps us deal with potential integer wraparound issues. + #endif + + enum + { + kAlignment = EASTL_ALIGN_OF(T), + kAlignmentOffset = 0 + }; + + public: + // CtorDoNotInitialize exists so that we can create a constructor that allocates but doesn't + // initialize and also doesn't collide with any other constructor declaration. + struct CtorDoNotInitialize{}; + + // CtorSprintf exists so that we can create a constructor that accepts printf-style + // arguments but also doesn't collide with any other constructor declaration. + struct CtorSprintf{}; + + protected: + value_type* mpBegin; // Begin of string. + value_type* mpEnd; // End of string. *mpEnd is always '0', as we 0-terminate our string. mpEnd is always < mpCapacity. + value_type* mpCapacity; // End of allocated space, including the space needed to store the trailing '0' char. mpCapacity is always at least mpEnd + 1. + allocator_type mAllocator; // To do: Use base class optimization to make this go away. + + public: + // Constructor, destructor + basic_string(); + explicit basic_string(const allocator_type& allocator); + basic_string(const this_type& x, size_type position, size_type n = npos); + basic_string(const value_type* p, size_type n, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR); + EASTL_STRING_EXPLICIT basic_string(const value_type* p, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR); + basic_string(size_type n, value_type c, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR); + basic_string(const this_type& x); + basic_string(const value_type* pBegin, const value_type* pEnd, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR); + basic_string(CtorDoNotInitialize, size_type n, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR); + basic_string(CtorSprintf, const value_type* pFormat, ...); + + ~basic_string(); + + // Allocator + const allocator_type& get_allocator() const; + allocator_type& get_allocator(); + void set_allocator(const allocator_type& allocator); + + // Operator = + this_type& operator=(const this_type& x); + this_type& operator=(const value_type* p); + this_type& operator=(value_type c); + + void swap(this_type& x); + + // Assignment operations + basic_string& assign(const basic_string& x); + basic_string& assign(const basic_string& x, size_type position, size_type n); + basic_string& assign(const value_type* p, size_type n); + basic_string& assign(const value_type* p); + basic_string& assign(size_type n, value_type c); + basic_string& assign(const value_type* pBegin, const value_type* pEnd); + + // Iterators. + iterator begin(); // Expanded in source code as: mpBegin + const_iterator begin() const; // Expanded in source code as: mpBegin + iterator end(); // Expanded in source code as: mpEnd + const_iterator end() const; // Expanded in source code as: mpEnd + + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; + reverse_iterator rend(); + const_reverse_iterator rend() const; + + // Size-related functionality + bool empty() const; // Expanded in source code as: (mpBegin == mpEnd) or (mpBegin != mpEnd) + size_type size() const; // Expanded in source code as: (size_type)(mpEnd - mpBegin) + size_type length() const; // Expanded in source code as: (size_type)(mpEnd - mpBegin) + size_type max_size() const; // Expanded in source code as: kMaxSize + size_type capacity() const; // Expanded in source code as: (size_type)((mpCapacity - mpBegin) - 1) + void resize(size_type n, value_type c); + void resize(size_type n); + void reserve(size_type = 0); + void set_capacity(size_type n = npos); // Revises the capacity to the user-specified value. Resizes the container to match the capacity if the requested capacity n is less than the current size. If n == npos then the capacity is reallocated (if necessary) such that capacity == size. + void force_size(size_type n); // Unilaterally moves the string end position (mpEnd) to the given location. Useful for when the user writes into the string via some extenal means such as C strcpy or sprintf. This allows for more efficient use than using resize to achieve this. + + // Raw access + const value_type* data() const; + const value_type* c_str() const; + + // Element access + reference operator[](size_type n); + const_reference operator[](size_type n) const; + reference at(size_type n); + const_reference at(size_type n) const; + reference front(); + const_reference front() const; + reference back(); + const_reference back() const; + + // Append operations + basic_string& operator+=(const basic_string& x); + basic_string& operator+=(const value_type* p); + basic_string& operator+=(value_type c); + + basic_string& append(const basic_string& x); + basic_string& append(const basic_string& x, size_type position, size_type n); + basic_string& append(const value_type* p, size_type n); + basic_string& append(const value_type* p); + basic_string& append(size_type n, value_type c); + basic_string& append(const value_type* pBegin, const value_type* pEnd); + + basic_string& append_sprintf_va_list(const value_type* pFormat, va_list arguments); + basic_string& append_sprintf(const value_type* pFormat, ...); + + void push_back(value_type c); + void pop_back(); + + // Insertion operations + basic_string& insert(size_type position, const basic_string& x); + basic_string& insert(size_type position, const basic_string& x, size_type beg, size_type n); + basic_string& insert(size_type position, const value_type* p, size_type n); + basic_string& insert(size_type position, const value_type* p); + basic_string& insert(size_type position, size_type n, value_type c); + iterator insert(iterator p, value_type c); + void insert(iterator p, size_type n, value_type c); + void insert(iterator p, const value_type* pBegin, const value_type* pEnd); + + // Erase operations + basic_string& erase(size_type position = 0, size_type n = npos); + iterator erase(iterator p); + iterator erase(iterator pBegin, iterator pEnd); + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + void clear(); + void reset(); // This is a unilateral reset to an initially empty state. No destructors are called, no deallocation occurs. + + //Replacement operations + basic_string& replace(size_type position, size_type n, const basic_string& x); + basic_string& replace(size_type pos1, size_type n1, const basic_string& x, size_type pos2, size_type n2); + basic_string& replace(size_type position, size_type n1, const value_type* p, size_type n2); + basic_string& replace(size_type position, size_type n1, const value_type* p); + basic_string& replace(size_type position, size_type n1, size_type n2, value_type c); + basic_string& replace(iterator first, iterator last, const basic_string& x); + basic_string& replace(iterator first, iterator last, const value_type* p, size_type n); + basic_string& replace(iterator first, iterator last, const value_type* p); + basic_string& replace(iterator first, iterator last, size_type n, value_type c); + basic_string& replace(iterator first, iterator last, const value_type* pBegin, const value_type* pEnd); + size_type copy(value_type* p, size_type n, size_type position = 0) const; + + // Find operations + size_type find(const basic_string& x, size_type position = 0) const; + size_type find(const value_type* p, size_type position = 0) const; + size_type find(const value_type* p, size_type position, size_type n) const; + size_type find(value_type c, size_type position = 0) const; + + // Reverse find operations + size_type rfind(const basic_string& x, size_type position = npos) const; + size_type rfind(const value_type* p, size_type position = npos) const; + size_type rfind(const value_type* p, size_type position, size_type n) const; + size_type rfind(value_type c, size_type position = npos) const; + + // Find first-of operations + size_type find_first_of(const basic_string& x, size_type position = 0) const; + size_type find_first_of(const value_type* p, size_type position = 0) const; + size_type find_first_of(const value_type* p, size_type position, size_type n) const; + size_type find_first_of(value_type c, size_type position = 0) const; + + // Find last-of operations + size_type find_last_of(const basic_string& x, size_type position = npos) const; + size_type find_last_of(const value_type* p, size_type position = npos) const; + size_type find_last_of(const value_type* p, size_type position, size_type n) const; + size_type find_last_of(value_type c, size_type position = npos) const; + + // Find first not-of operations + size_type find_first_not_of(const basic_string& x, size_type position = 0) const; + size_type find_first_not_of(const value_type* p, size_type position = 0) const; + size_type find_first_not_of(const value_type* p, size_type position, size_type n) const; + size_type find_first_not_of(value_type c, size_type position = 0) const; + + // Find last not-of operations + size_type find_last_not_of(const basic_string& x, size_type position = npos) const; + size_type find_last_not_of(const value_type* p, size_type position = npos) const; + size_type find_last_not_of(const value_type* p, size_type position, size_type n) const; + size_type find_last_not_of(value_type c, size_type position = npos) const; + + // Substring functionality + basic_string substr(size_type position = 0, size_type n = npos) const; + + // Comparison operations + int compare(const basic_string& x) const; + int compare(size_type pos1, size_type n1, const basic_string& x) const; + int compare(size_type pos1, size_type n1, const basic_string& x, size_type pos2, size_type n2) const; + int compare(const value_type* p) const; + int compare(size_type pos1, size_type n1, const value_type* p) const; + int compare(size_type pos1, size_type n1, const value_type* p, size_type n2) const; + static int compare(const value_type* pBegin1, const value_type* pEnd1, const value_type* pBegin2, const value_type* pEnd2); + + // Case-insensitive comparison functions. Not part of C++ basic_string. Only ASCII-level locale functionality is supported. Thus this is not suitable for localization purposes. + int comparei(const basic_string& x) const; + int comparei(const value_type* p) const; + static int comparei(const value_type* pBegin1, const value_type* pEnd1, const value_type* pBegin2, const value_type* pEnd2); + + // Misc functionality, not part of C++ basic_string. + void make_lower(); + void make_upper(); + void ltrim(); + void rtrim(); + void trim(); + basic_string left(size_type n) const; + basic_string right(size_type n) const; + basic_string& sprintf_va_list(const value_type* pFormat, va_list arguments); + basic_string& sprintf(const value_type* pFormat, ...); + + bool validate() const; + int validate_iterator(const_iterator i) const; + + protected: + // Helper functions for initialization/insertion operations. + value_type* DoAllocate(size_type n); + void DoFree(value_type* p, size_type n); + size_type GetNewCapacity(size_type currentCapacity); + + void AllocateSelf(); + void AllocateSelf(size_type n); + void DeallocateSelf(); + iterator InsertInternal(iterator p, value_type c); + void RangeInitialize(const value_type* pBegin, const value_type* pEnd); + void RangeInitialize(const value_type* pBegin); + void SizeInitialize(size_type n, value_type c); + void ThrowLengthException() const; + void ThrowRangeException() const; + void ThrowInvalidArgumentException() const; + + // Replacements for STL template functions. + static const value_type* CharTypeStringFindEnd(const value_type* pBegin, const value_type* pEnd, value_type c); + static const value_type* CharTypeStringRFind(const value_type* pRBegin, const value_type* pREnd, const value_type c); + static const value_type* CharTypeStringSearch(const value_type* p1Begin, const value_type* p1End, const value_type* p2Begin, const value_type* p2End); + static const value_type* CharTypeStringRSearch(const value_type* p1Begin, const value_type* p1End, const value_type* p2Begin, const value_type* p2End); + static const value_type* CharTypeStringFindFirstOf(const value_type* p1Begin, const value_type* p1End, const value_type* p2Begin, const value_type* p2End); + static const value_type* CharTypeStringRFindFirstOf(const value_type* p1RBegin, const value_type* p1REnd, const value_type* p2Begin, const value_type* p2End); + static const value_type* CharTypeStringFindFirstNotOf(const value_type* p1Begin, const value_type* p1End, const value_type* p2Begin, const value_type* p2End); + static const value_type* CharTypeStringRFindFirstNotOf(const value_type* p1RBegin, const value_type* p1REnd, const value_type* p2Begin, const value_type* p2End); + + }; // basic_string + + + + + /////////////////////////////////////////////////////////////////////////////// + // 'char traits' functionality + // + inline char8_t CharToLower(char8_t c) + { return (char8_t)tolower((uint8_t)c); } + + inline char16_t CharToLower(char16_t c) + { if((unsigned)c <= 0xff) return (char16_t)tolower((uint8_t)c); return c; } + + inline char32_t CharToLower(char32_t c) + { if((unsigned)c <= 0xff) return (char32_t)tolower((uint8_t)c); return c; } + + + + inline char8_t CharToUpper(char8_t c) + { return (char8_t)toupper((uint8_t)c); } + + inline char16_t CharToUpper(char16_t c) + { if((unsigned)c <= 0xff) return (char16_t)toupper((uint8_t)c); return c; } + + inline char32_t CharToUpper(char32_t c) + { if((unsigned)c <= 0xff) return (char32_t)toupper((uint8_t)c); return c; } + + + + template + int Compare(const T* p1, const T* p2, size_t n) + { + for(; n > 0; ++p1, ++p2, --n) + { + if(*p1 != *p2) + return (*p1 < *p2) ? -1 : 1; + } + return 0; + } + + inline int Compare(const char8_t* p1, const char8_t* p2, size_t n) + { + return memcmp(p1, p2, n); + } + + template + inline int CompareI(const T* p1, const T* p2, size_t n) + { + for(; n > 0; ++p1, ++p2, --n) + { + const T c1 = CharToLower(*p1); + const T c2 = CharToLower(*p2); + + if(c1 != c2) + return (c1 < c2) ? -1 : 1; + } + return 0; + } + + + inline const char8_t* Find(const char8_t* p, char8_t c, size_t n) + { + return (const char8_t*)memchr(p, c, n); + } + + inline const char16_t* Find(const char16_t* p, char16_t c, size_t n) + { + for(; n > 0; --n, ++p) + { + if(*p == c) + return p; + } + + return NULL; + } + + inline const char32_t* Find(const char32_t* p, char32_t c, size_t n) + { + for(; n > 0; --n, ++p) + { + if(*p == c) + return p; + } + + return NULL; + } + + + inline size_t CharStrlen(const char8_t* p) + { + #ifdef _MSC_VER // VC++ can implement an instrinsic here. + return strlen(p); + #else + const char8_t* pCurrent = p; + while(*pCurrent) + ++pCurrent; + return (size_t)(pCurrent - p); + #endif + } + + inline size_t CharStrlen(const char16_t* p) + { + const char16_t* pCurrent = p; + while(*pCurrent) + ++pCurrent; + return (size_t)(pCurrent - p); + } + + inline size_t CharStrlen(const char32_t* p) + { + const char32_t* pCurrent = p; + while(*pCurrent) + ++pCurrent; + return (size_t)(pCurrent - p); + } + + + template + inline T* CharStringUninitializedCopy(const T* pSource, const T* pSourceEnd, T* pDestination) + { + memmove(pDestination, pSource, (size_t)(pSourceEnd - pSource) * sizeof(T)); + return pDestination + (pSourceEnd - pSource); + } + + + + + inline char8_t* CharStringUninitializedFillN(char8_t* pDestination, size_t n, const char8_t c) + { + if(n) // Some compilers (e.g. GCC 4.3+) generate a warning (which can't be disabled) if you call memset with a size of 0. + memset(pDestination, (uint8_t)c, (size_t)n); + return pDestination + n; + } + + inline char16_t* CharStringUninitializedFillN(char16_t* pDestination, size_t n, const char16_t c) + { + char16_t* pDest16 = pDestination; + const char16_t* const pEnd = pDestination + n; + while(pDest16 < pEnd) + *pDest16++ = c; + return pDestination + n; + } + + inline char32_t* CharStringUninitializedFillN(char32_t* pDestination, size_t n, const char32_t c) + { + char32_t* pDest32 = pDestination; + const char32_t* const pEnd = pDestination + n; + while(pDest32 < pEnd) + *pDest32++ = c; + return pDestination + n; + } + + + + inline char8_t* CharTypeAssignN(char8_t* pDestination, size_t n, char8_t c) + { + if(n) // Some compilers (e.g. GCC 4.3+) generate a warning (which can't be disabled) if you call memset with a size of 0. + return (char8_t*)memset(pDestination, c, (size_t)n); + return pDestination; + } + + inline char16_t* CharTypeAssignN(char16_t* pDestination, size_t n, char16_t c) + { + char16_t* pDest16 = pDestination; + const char16_t* const pEnd = pDestination + n; + while(pDest16 < pEnd) + *pDest16++ = c; + return pDestination; + } + + inline char32_t* CharTypeAssignN(char32_t* pDestination, size_t n, char32_t c) + { + char32_t* pDest32 = pDestination; + const char32_t* const pEnd = pDestination + n; + while(pDest32 < pEnd) + *pDest32++ = c; + return pDestination; + } + + + + /////////////////////////////////////////////////////////////////////////////// + // basic_string + /////////////////////////////////////////////////////////////////////////////// + + template + inline basic_string::basic_string() + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(EASTL_BASIC_STRING_DEFAULT_NAME) + { + AllocateSelf(); + } + + + template + inline basic_string::basic_string(const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + AllocateSelf(); + } + + + template + inline basic_string::basic_string(const this_type& x) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(x.mAllocator) + { + RangeInitialize(x.mpBegin, x.mpEnd); + } + + + template + basic_string::basic_string(const this_type& x, size_type position, size_type n) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(x.mAllocator) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(x.mpEnd - x.mpBegin))) + { + ThrowRangeException(); + AllocateSelf(); + } + else + RangeInitialize(x.mpBegin + position, x.mpBegin + position + eastl::min_alt(n, (size_type)(x.mpEnd - x.mpBegin) - position)); + #else + RangeInitialize(x.mpBegin + position, x.mpBegin + position + eastl::min_alt(n, (size_type)(x.mpEnd - x.mpBegin) - position)); + #endif + } + + + template + inline basic_string::basic_string(const value_type* p, size_type n, const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + RangeInitialize(p, p + n); + } + + + template + inline basic_string::basic_string(const value_type* p, const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + RangeInitialize(p); + } + + + template + inline basic_string::basic_string(size_type n, value_type c, const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + SizeInitialize(n, c); + } + + + template + inline basic_string::basic_string(const value_type* pBegin, const value_type* pEnd, const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + RangeInitialize(pBegin, pEnd); + } + + + // CtorDoNotInitialize exists so that we can create a version that allocates but doesn't + // initialize but also doesn't collide with any other constructor declaration. + template + basic_string::basic_string(CtorDoNotInitialize /*unused*/, size_type n, const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + // Note that we do not call SizeInitialize here. + AllocateSelf(n + 1); // '+1' so that we have room for the terminating 0. + *mpEnd = 0; + } + + + // CtorSprintf exists so that we can create a version that does a variable argument + // sprintf but also doesn't collide with any other constructor declaration. + template + basic_string::basic_string(CtorSprintf /*unused*/, const value_type* pFormat, ...) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator() + { + const size_type n = (size_type)CharStrlen(pFormat) + 1; // We'll need at least this much. '+1' so that we have room for the terminating 0. + AllocateSelf(n); + + va_list arguments; + va_start(arguments, pFormat); + append_sprintf_va_list(pFormat, arguments); + va_end(arguments); + } + + + template + inline basic_string::~basic_string() + { + DeallocateSelf(); + } + + + template + inline const typename basic_string::allocator_type& + basic_string::get_allocator() const + { + return mAllocator; + } + + + template + inline typename basic_string::allocator_type& + basic_string::get_allocator() + { + return mAllocator; + } + + + template + inline void basic_string::set_allocator(const allocator_type& allocator) + { + mAllocator = allocator; + } + + + template + inline const typename basic_string::value_type* + basic_string::data() const + { + return mpBegin; + } + + + template + inline const typename basic_string::value_type* + basic_string::c_str() const + { + return mpBegin; + } + + + template + inline typename basic_string::iterator + basic_string::begin() + { + return mpBegin; + } + + + template + inline typename basic_string::iterator + basic_string::end() + { + return mpEnd; + } + + + template + inline typename basic_string::const_iterator + basic_string::begin() const + { + return mpBegin; + } + + + template + inline typename basic_string::const_iterator + basic_string::end() const + { + return mpEnd; + } + + + template + inline typename basic_string::reverse_iterator + basic_string::rbegin() + { + return reverse_iterator(mpEnd); + } + + + template + inline typename basic_string::reverse_iterator + basic_string::rend() + { + return reverse_iterator(mpBegin); + } + + + template + inline typename basic_string::const_reverse_iterator + basic_string::rbegin() const + { + return const_reverse_iterator(mpEnd); + } + + + template + inline typename basic_string::const_reverse_iterator + basic_string::rend() const + { + return const_reverse_iterator(mpBegin); + } + + + template + inline bool basic_string::empty() const + { + return (mpBegin == mpEnd); + } + + + template + inline typename basic_string::size_type + basic_string::size() const + { + return (size_type)(mpEnd - mpBegin); + } + + + template + inline typename basic_string::size_type + basic_string::length() const + { + return (size_type)(mpEnd - mpBegin); + } + + + template + inline typename basic_string::size_type + basic_string::max_size() const + { + return kMaxSize; + } + + + template + inline typename basic_string::size_type + basic_string::capacity() const + { + return (size_type)((mpCapacity - mpBegin) - 1); // '-1' because we pretend that we didn't allocate memory for the terminating 0. + } + + + template + inline typename basic_string::const_reference + basic_string::operator[](size_type n) const + { + #if EASTL_ASSERT_ENABLED // We allow the user to reference the trailing 0 char without asserting. Perhaps we shouldn't. + if(EASTL_UNLIKELY(n > (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("basic_string::operator[] -- out of range"); + #endif + + return mpBegin[n]; // Sometimes done as *(mpBegin + n) + } + + + template + inline typename basic_string::reference + basic_string::operator[](size_type n) + { + #if EASTL_ASSERT_ENABLED // We allow the user to reference the trailing 0 char without asserting. Perhaps we shouldn't. + if(EASTL_UNLIKELY(n > (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("basic_string::operator[] -- out of range"); + #endif + + return mpBegin[n]; // Sometimes done as *(mpBegin + n) + } + + + template + inline typename basic_string::this_type& basic_string::operator=(const basic_string& x) + { + if(&x != this) + { + #if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; + #endif + + assign(x.mpBegin, x.mpEnd); + } + return *this; + } + + + template + inline typename basic_string::this_type& basic_string::operator=(const value_type* p) + { + return assign(p, p + CharStrlen(p)); + } + + + template + inline typename basic_string::this_type& basic_string::operator=(value_type c) + { + return assign((size_type)1, c); + } + + + template + void basic_string::resize(size_type n, value_type c) + { + const size_type s = (size_type)(mpEnd - mpBegin); + + if(n < s) + erase(mpBegin + n, mpEnd); + else if(n > s) + append(n - s, c); + } + + + template + void basic_string::resize(size_type n) + { + // C++ basic_string specifies that resize(n) is equivalent to resize(n, value_type()). + // For built-in types, value_type() is the same as zero (value_type(0)). + // We can improve the efficiency (especially for long strings) of this + // string class by resizing without assigning to anything. + + const size_type s = (size_type)(mpEnd - mpBegin); + + if(n < s) + erase(mpBegin + n, mpEnd); + else if(n > s) + { + #if EASTL_STRING_OPT_CHAR_INIT + append(n - s, value_type()); + #else + append(n - s); + #endif + } + } + + + template + void basic_string::reserve(size_type n) + { + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY(n > kMaxSize)) + ThrowLengthException(); + #endif + + // The C++ standard for basic_string doesn't specify if we should or shouldn't + // downsize the container. The standard is overly vague in its description of reserve: + // The member function reserve() is a directive that informs a + // basic_string object of a planned change in size, so that it + // can manage the storage allocation accordingly. + // We will act like the vector container and preserve the contents of + // the container and only reallocate if increasing the size. The user + // can use the set_capacity function to reduce the capacity. + + n = eastl::max_alt(n, (size_type)(mpEnd - mpBegin)); // Calculate the new capacity, which needs to be >= container size. + + if(n >= (size_type)(mpCapacity - mpBegin)) // If there is something to do... // We use >= because mpCapacity accounts for the trailing zero. + set_capacity(n); + } + + + template + inline void basic_string::set_capacity(size_type n) + { + if(n == npos) // If the user wants to set the capacity to equal the current size... // '-1' because we pretend that we didn't allocate memory for the terminating 0. + n = (size_type)(mpEnd - mpBegin); + else if(n < (size_type)(mpEnd - mpBegin)) + mpEnd = mpBegin + n; + + if(n != (size_type)((mpCapacity - mpBegin) - 1)) // If there is any capacity change... + { + if(n) + { + pointer pNewBegin = DoAllocate(n + 1); // We need the + 1 to accomodate the trailing 0. + pointer pNewEnd = pNewBegin; + + pNewEnd = CharStringUninitializedCopy(mpBegin, mpEnd, pNewBegin); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + (n + 1); + } + else + { + DeallocateSelf(); + AllocateSelf(); + } + } + } + + + template + inline void basic_string::force_size(size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(n >= (size_type)(mpCapacity - mpBegin))) + ThrowRangeException(); + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= (size_type)(mpCapacity - mpBegin))) + EASTL_FAIL_MSG("basic_string::force_size -- out of range"); + #endif + + mpEnd = mpBegin + n; + } + + + template + inline void basic_string::clear() + { + if(mpBegin != mpEnd) + { + *mpBegin = value_type(0); + mpEnd = mpBegin; + } + } + + + template + inline void basic_string::reset() + { + // The reset function is a special extension function which unilaterally + // resets the container to an empty state without freeing the memory of + // the contained objects. This is useful for very quickly tearing down a + // container built into scratch memory. + AllocateSelf(); + } + + + template + inline typename basic_string::const_reference + basic_string::at(size_type n) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(n >= (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #elif EASTL_ASSERT_ENABLED // We assert if the user references the trailing 0 char. + if(EASTL_UNLIKELY(n >= (size_type)(mpEnd - mpBegin))) + EASTL_FAIL_MSG("basic_string::at -- out of range"); + #endif + + return mpBegin[n]; + } + + + template + inline typename basic_string::reference + basic_string::at(size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(n >= (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #elif EASTL_ASSERT_ENABLED // We assert if the user references the trailing 0 char. + if(EASTL_UNLIKELY(n >= (size_type)(mpEnd - mpBegin))) + EASTL_FAIL_MSG("basic_string::at -- out of range"); + #endif + + return mpBegin[n]; + } + + + template + inline typename basic_string::reference + basic_string::front() + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference the trailing 0 char without asserting. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We assert if the user references the trailing 0 char. + EASTL_FAIL_MSG("basic_string::front -- empty string"); + #endif + + return *mpBegin; + } + + + template + inline typename basic_string::const_reference + basic_string::front() const + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference the trailing 0 char without asserting. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We assert if the user references the trailing 0 char. + EASTL_FAIL_MSG("basic_string::front -- empty string"); + #endif + + return *mpBegin; + } + + + template + inline typename basic_string::reference + basic_string::back() + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference the trailing 0 char without asserting. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We assert if the user references the trailing 0 char. + EASTL_FAIL_MSG("basic_string::back -- empty string"); + #endif + + return *(mpEnd - 1); + } + + + template + inline typename basic_string::const_reference + basic_string::back() const + { + #if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference the trailing 0 char without asserting. + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We assert if the user references the trailing 0 char. + EASTL_FAIL_MSG("basic_string::back -- empty string"); + #endif + + return *(mpEnd - 1); + } + + + template + inline basic_string& basic_string::operator+=(const basic_string& x) + { + return append(x); + } + + + template + inline basic_string& basic_string::operator+=(const value_type* p) + { + return append(p); + } + + + template + inline basic_string& basic_string::operator+=(value_type c) + { + push_back(c); + return *this; + } + + + template + inline basic_string& basic_string::append(const basic_string& x) + { + return append(x.mpBegin, x.mpEnd); + } + + + template + inline basic_string& basic_string::append(const basic_string& x, size_type position, size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(x.mpEnd - x.mpBegin))) + ThrowRangeException(); + #endif + + return append(x.mpBegin + position, x.mpBegin + position + eastl::min_alt(n, (size_type)(x.mpEnd - x.mpBegin) - position)); + } + + + template + inline basic_string& basic_string::append(const value_type* p, size_type n) + { + return append(p, p + n); + } + + + template + inline basic_string& basic_string::append(const value_type* p) + { + return append(p, p + CharStrlen(p)); + } + + + template + basic_string& basic_string::append(size_type n, value_type c) + { + const size_type s = (size_type)(mpEnd - mpBegin); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((n > kMaxSize) || (s > (kMaxSize - n)))) + ThrowLengthException(); + #endif + + const size_type nCapacity = (size_type)((mpCapacity - mpBegin) - 1); + + if((s + n) > nCapacity) + reserve(eastl::max_alt((size_type)GetNewCapacity(nCapacity), (size_type)(s + n))); + + if(n > 0) + { + CharStringUninitializedFillN(mpEnd + 1, n - 1, c); + *mpEnd = c; + mpEnd += n; + *mpEnd = 0; + } + + return *this; + } + + + template + basic_string& basic_string::append(const value_type* pBegin, const value_type* pEnd) + { + if(pBegin != pEnd) + { + const size_type nOldSize = (size_type)(mpEnd - mpBegin); + const size_type n = (size_type)(pEnd - pBegin); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY(((size_t)n > kMaxSize) || (nOldSize > (kMaxSize - n)))) + ThrowLengthException(); + #endif + + const size_type nCapacity = (size_type)((mpCapacity - mpBegin) - 1); + + if((nOldSize + n) > nCapacity) + { + const size_type nLength = eastl::max_alt((size_type)GetNewCapacity(nCapacity), (size_type)(nOldSize + n)) + 1; // + 1 to accomodate the trailing 0. + + pointer pNewBegin = DoAllocate(nLength); + pointer pNewEnd = pNewBegin; + + pNewEnd = CharStringUninitializedCopy(mpBegin, mpEnd, pNewBegin); + pNewEnd = CharStringUninitializedCopy(pBegin, pEnd, pNewEnd); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + nLength; + } + else + { + const value_type* pTemp = pBegin; + ++pTemp; + CharStringUninitializedCopy(pTemp, pEnd, mpEnd + 1); + mpEnd[n] = 0; + *mpEnd = *pBegin; + mpEnd += n; + } + } + + return *this; + } + + + template + basic_string& basic_string::append_sprintf_va_list(const value_type* pFormat, va_list arguments) + { + // From unofficial C89 extension documentation: + // The vsnprintf returns the number of characters written into the array, + // not counting the terminating null character, or a negative value + // if count or more characters are requested to be generated. + // An error can occur while converting a value for output. + + // From the C99 standard: + // The vsnprintf function returns the number of characters that would have + // been written had n been sufficiently large, not counting the terminating + // null character, or a negative value if an encoding error occurred. + // Thus, the null-terminated output has been completely written if and only + // if the returned value is nonnegative and less than n. + size_type nInitialSize = (size_type)(mpEnd - mpBegin); + int nReturnValue; + + #if EASTL_VA_COPY_ENABLED + va_list argumentsSaved; + va_copy(argumentsSaved, arguments); + #endif + + if(mpBegin == GetEmptyString(value_type())) // We need to do this because non-standard vsnprintf implementations will otherwise overwrite gEmptyString with a non-zero char. + nReturnValue = eastl::Vsnprintf(mpEnd, 0, pFormat, arguments); + else + nReturnValue = eastl::Vsnprintf(mpEnd, (size_t)(mpCapacity - mpEnd), pFormat, arguments); + + if(nReturnValue >= (int)(mpCapacity - mpEnd)) // If there wasn't enough capacity... + { + // In this case we definitely have C99 Vsnprintf behaviour. + #if EASTL_VA_COPY_ENABLED + va_copy(arguments, argumentsSaved); + #endif + resize(nInitialSize + nReturnValue); + nReturnValue = eastl::Vsnprintf(mpBegin + nInitialSize, (size_t)(nReturnValue + 1), pFormat, arguments); // '+1' because vsnprintf wants to know the size of the buffer including the terminating zero. + } + else if(nReturnValue < 0) // If vsnprintf is non-C99-standard (e.g. it is VC++ _vsnprintf)... + { + // In this case we either have C89 extension behaviour or C99 behaviour. + size_type n = eastl::max_alt((size_type)(EASTL_STRING_INITIAL_CAPACITY - 1), (size_type)(size() * 2)); // '-1' because the resize call below will add one for NULL terminator and we want to keep allocations on fixed block sizes. + + for(; (nReturnValue < 0) && (n < 1000000); n *= 2) + { + #if EASTL_VA_COPY_ENABLED + va_copy(arguments, argumentsSaved); + #endif + resize(n); + + const size_t nCapacity = (size_t)((n + 1) - nInitialSize); + nReturnValue = eastl::Vsnprintf(mpBegin + nInitialSize, nCapacity, pFormat, arguments); // '+1' because vsnprintf wants to know the size of the buffer including the terminating zero. + + if(nReturnValue == (int)(unsigned)nCapacity) + { + resize(++n); + nReturnValue = eastl::Vsnprintf(mpBegin + nInitialSize, nCapacity + 1, pFormat, arguments); + } + } + } + + if(nReturnValue >= 0) + mpEnd = mpBegin + nInitialSize + nReturnValue; // We are guaranteed from the above logic that mpEnd <= mpCapacity. + + return *this; + } + + template + basic_string& basic_string::append_sprintf(const value_type* pFormat, ...) + { + va_list arguments; + va_start(arguments, pFormat); + append_sprintf_va_list(pFormat, arguments); + va_end(arguments); + + return *this; + } + + + template + inline void basic_string::push_back(value_type c) + { + if((mpEnd + 1) == mpCapacity) // If we are out of space... (note that we test for + 1 because we have a trailing 0) + reserve(eastl::max_alt(GetNewCapacity((size_type)((mpCapacity - mpBegin) - 1)), (size_type)(mpEnd - mpBegin) + 1)); + *mpEnd++ = c; + *mpEnd = 0; + } + + + template + inline void basic_string::pop_back() + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) + EASTL_FAIL_MSG("basic_string::pop_back -- empty string"); + #endif + + mpEnd[-1] = value_type(0); + --mpEnd; + } + + + template + inline basic_string& basic_string::assign(const basic_string& x) + { + return assign(x.mpBegin, x.mpEnd); + } + + + template + inline basic_string& basic_string::assign(const basic_string& x, size_type position, size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(x.mpEnd - x.mpBegin))) + ThrowRangeException(); + #endif + + return assign(x.mpBegin + position, x.mpBegin + position + eastl::min_alt(n, (size_type)(x.mpEnd - x.mpBegin) - position)); + } + + + template + inline basic_string& basic_string::assign(const value_type* p, size_type n) + { + return assign(p, p + n); + } + + + template + inline basic_string& basic_string::assign(const value_type* p) + { + return assign(p, p + CharStrlen(p)); + } + + + template + basic_string& basic_string::assign(size_type n, value_type c) + { + if(n <= (size_type)(mpEnd - mpBegin)) + { + CharTypeAssignN(mpBegin, n, c); + erase(mpBegin + n, mpEnd); + } + else + { + CharTypeAssignN(mpBegin, (size_type)(mpEnd - mpBegin), c); + append(n - (size_type)(mpEnd - mpBegin), c); + } + return *this; + } + + + template + basic_string& basic_string::assign(const value_type* pBegin, const value_type* pEnd) + { + const ptrdiff_t n = pEnd - pBegin; + if(static_cast(n) <= (size_type)(mpEnd - mpBegin)) + { + memmove(mpBegin, pBegin, (size_t)n * sizeof(value_type)); + erase(mpBegin + n, mpEnd); + } + else + { + memmove(mpBegin, pBegin, (size_t)(mpEnd - mpBegin) * sizeof(value_type)); + append(pBegin + (size_type)(mpEnd - mpBegin), pEnd); + } + return *this; + } + + + template + basic_string& basic_string::insert(size_type position, const basic_string& x) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((size_type)(mpEnd - mpBegin) > (kMaxSize - (size_type)(x.mpEnd - x.mpBegin)))) + ThrowLengthException(); + #endif + + insert(mpBegin + position, x.mpBegin, x.mpEnd); + return *this; + } + + + template + basic_string& basic_string::insert(size_type position, const basic_string& x, size_type beg, size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY((position > (size_type)(mpEnd - mpBegin)) || (beg > (size_type)(x.mpEnd - x.mpBegin)))) + ThrowRangeException(); + #endif + + size_type nLength = eastl::min_alt(n, (size_type)(x.mpEnd - x.mpBegin) - beg); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((size_type)(mpEnd - mpBegin) > (kMaxSize - nLength))) + ThrowLengthException(); + #endif + + insert(mpBegin + position, x.mpBegin + beg, x.mpBegin + beg + nLength); + return *this; + } + + + template + basic_string& basic_string::insert(size_type position, const value_type* p, size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((size_type)(mpEnd - mpBegin) > (kMaxSize - n))) + ThrowLengthException(); + #endif + + insert(mpBegin + position, p, p + n); + return *this; + } + + + template + basic_string& basic_string::insert(size_type position, const value_type* p) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + size_type nLength = (size_type)CharStrlen(p); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((size_type)(mpEnd - mpBegin) > (kMaxSize - nLength))) + ThrowLengthException(); + #endif + + insert(mpBegin + position, p, p + nLength); + return *this; + } + + + template + basic_string& basic_string::insert(size_type position, size_type n, value_type c) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((size_type)(mpEnd - mpBegin) > (kMaxSize - n))) + ThrowLengthException(); + #endif + + insert(mpBegin + position, n, c); + return *this; + } + + + template + inline typename basic_string::iterator + basic_string::insert(iterator p, value_type c) + { + if(p == mpEnd) + { + push_back(c); + return mpEnd - 1; + } + return InsertInternal(p, c); + } + + + template + void basic_string::insert(iterator p, size_type n, value_type c) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((p < mpBegin) || (p > mpEnd))) + EASTL_FAIL_MSG("basic_string::insert -- invalid position"); + #endif + + if(n) // If there is anything to insert... + { + if(size_type(mpCapacity - mpEnd) >= (n + 1)) // If we have enough capacity... + { + const size_type nElementsAfter = (size_type)(mpEnd - p); + iterator pOldEnd = mpEnd; + + if(nElementsAfter >= n) // If there's enough space for the new chars between the insert position and the end... + { + CharStringUninitializedCopy((mpEnd - n) + 1, mpEnd + 1, mpEnd + 1); + mpEnd += n; + memmove(p + n, p, (size_t)((nElementsAfter - n) + 1) * sizeof(value_type)); + CharTypeAssignN(p, n, c); + } + else + { + CharStringUninitializedFillN(mpEnd + 1, n - nElementsAfter - 1, c); + mpEnd += n - nElementsAfter; + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + CharStringUninitializedCopy(p, pOldEnd + 1, mpEnd); + mpEnd += nElementsAfter; + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + mpEnd = pOldEnd; + throw; + } + #endif + + CharTypeAssignN(p, nElementsAfter + 1, c); + } + } + else + { + const size_type nOldSize = (size_type)(mpEnd - mpBegin); + const size_type nOldCap = (size_type)((mpCapacity - mpBegin) - 1); + const size_type nLength = eastl::max_alt((size_type)GetNewCapacity(nOldCap), (size_type)(nOldSize + n)) + 1; // + 1 to accomodate the trailing 0. + + iterator pNewBegin = DoAllocate(nLength); + iterator pNewEnd = pNewBegin; + + pNewEnd = CharStringUninitializedCopy(mpBegin, p, pNewBegin); + pNewEnd = CharStringUninitializedFillN(pNewEnd, n, c); + pNewEnd = CharStringUninitializedCopy(p, mpEnd, pNewEnd); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + nLength; + } + } + } + + + template + void basic_string::insert(iterator p, const value_type* pBegin, const value_type* pEnd) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((p < mpBegin) || (p > mpEnd))) + EASTL_FAIL_MSG("basic_string::insert -- invalid position"); + #endif + + const size_type n = (size_type)(pEnd - pBegin); + + if(n) + { + const bool bCapacityIsSufficient = ((mpCapacity - mpEnd) >= (difference_type)(n + 1)); + const bool bSourceIsFromSelf = ((pEnd >= mpBegin) && (pBegin <= mpEnd)); + + // If bSourceIsFromSelf is true, then we reallocate. This is because we are + // inserting ourself into ourself and thus both the source and destination + // be modified, making it rather tricky to attempt to do in place. The simplest + // resolution is to reallocate. To consider: there may be a way to implement this + // whereby we don't need to reallocate or can often avoid reallocating. + if(bCapacityIsSufficient && !bSourceIsFromSelf) + { + const ptrdiff_t nElementsAfter = (mpEnd - p); + iterator pOldEnd = mpEnd; + + if(nElementsAfter >= (ptrdiff_t)n) // If the newly inserted characters entirely fit within the size of the original string... + { + memmove(mpEnd + 1, mpEnd - n + 1, (size_t)n * sizeof(value_type)); + mpEnd += n; + memmove(p + n, p, (size_t)((nElementsAfter - n) + 1) * sizeof(value_type)); + memmove(p, pBegin, (size_t)(pEnd - pBegin) * sizeof(value_type)); + } + else + { + const value_type* const pMid = pBegin + (nElementsAfter + 1); + + memmove(mpEnd + 1, pMid, (size_t)(pEnd - pMid) * sizeof(value_type)); + mpEnd += n - nElementsAfter; + + #if EASTL_EXCEPTIONS_ENABLED + try + { + #endif + memmove(mpEnd, p, (size_t)(pOldEnd - p + 1) * sizeof(value_type)); + mpEnd += nElementsAfter; + #if EASTL_EXCEPTIONS_ENABLED + } + catch(...) + { + mpEnd = pOldEnd; + throw; + } + #endif + + memmove(p, pBegin, (size_t)(pMid - pBegin) * sizeof(value_type)); + } + } + else // Else we need to reallocate to implement this. + { + const size_type nOldSize = (size_type)(mpEnd - mpBegin); + const size_type nOldCap = (size_type)((mpCapacity - mpBegin) - 1); + size_type nLength; + + if(bCapacityIsSufficient) // If bCapacityIsSufficient is true, then bSourceIsFromSelf must be false. + nLength = nOldSize + n + 1; // + 1 to accomodate the trailing 0. + else + nLength = eastl::max_alt((size_type)GetNewCapacity(nOldCap), (size_type)(nOldSize + n)) + 1; // + 1 to accomodate the trailing 0. + + pointer pNewBegin = DoAllocate(nLength); + pointer pNewEnd = pNewBegin; + + pNewEnd = CharStringUninitializedCopy(mpBegin, p, pNewBegin); + pNewEnd = CharStringUninitializedCopy(pBegin, pEnd, pNewEnd); + pNewEnd = CharStringUninitializedCopy(p, mpEnd, pNewEnd); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + nLength; + } + } + } + + + template + inline basic_string& basic_string::erase(size_type position, size_type n) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + EASTL_FAIL_MSG("basic_string::erase -- invalid position"); + #endif + + erase(mpBegin + position, mpBegin + position + eastl::min_alt(n, (size_type)(mpEnd - mpBegin) - position)); + return *this; + } + + + template + inline typename basic_string::iterator + basic_string::erase(iterator p) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((p < mpBegin) || (p >= mpEnd))) + EASTL_FAIL_MSG("basic_string::erase -- invalid position"); + #endif + + memmove(p, p + 1, (size_t)(mpEnd - p) * sizeof(value_type)); + --mpEnd; + return p; + } + + + template + typename basic_string::iterator + basic_string::erase(iterator pBegin, iterator pEnd) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((pBegin < mpBegin) || (pBegin > mpEnd) || (pEnd < mpBegin) || (pEnd > mpEnd) || (pEnd < pBegin))) + EASTL_FAIL_MSG("basic_string::erase -- invalid position"); + #endif + + if(pBegin != pEnd) + { + memmove(pBegin, pEnd, (size_t)((mpEnd - pEnd) + 1) * sizeof(value_type)); + const iterator pNewEnd = (mpEnd - (pEnd - pBegin)); + mpEnd = pNewEnd; + } + return pBegin; + } + + + template + inline typename basic_string::reverse_iterator + basic_string::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + typename basic_string::reverse_iterator + basic_string::erase(reverse_iterator first, reverse_iterator last) + { + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + basic_string& basic_string::replace(size_type position, size_type n, const basic_string& x) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + const size_type nLength = eastl::min_alt(n, (size_type)(mpEnd - mpBegin) - position); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY(((size_type)(mpEnd - mpBegin) - nLength) >= (kMaxSize - (size_type)(x.mpEnd - x.mpBegin)))) + ThrowLengthException(); + #endif + + return replace(mpBegin + position, mpBegin + position + nLength, x.mpBegin, x.mpEnd); + } + + + template + basic_string& basic_string::replace(size_type pos1, size_type n1, const basic_string& x, size_type pos2, size_type n2) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY((pos1 > (size_type)(mpEnd - mpBegin)) || (pos2 > (size_type)(x.mpEnd - x.mpBegin)))) + ThrowRangeException(); + #endif + + const size_type nLength1 = eastl::min_alt(n1, (size_type)( mpEnd - mpBegin) - pos1); + const size_type nLength2 = eastl::min_alt(n2, (size_type)(x.mpEnd - x.mpBegin) - pos2); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY(((size_type)(mpEnd - mpBegin) - nLength1) >= (kMaxSize - nLength2))) + ThrowLengthException(); + #endif + + return replace(mpBegin + pos1, mpBegin + pos1 + nLength1, x.mpBegin + pos2, x.mpBegin + pos2 + nLength2); + } + + + template + basic_string& basic_string::replace(size_type position, size_type n1, const value_type* p, size_type n2) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + const size_type nLength = eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - position); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((n2 > kMaxSize) || (((size_type)(mpEnd - mpBegin) - nLength) >= (kMaxSize - n2)))) + ThrowLengthException(); + #endif + + return replace(mpBegin + position, mpBegin + position + nLength, p, p + n2); + } + + + template + basic_string& basic_string::replace(size_type position, size_type n1, const value_type* p) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + const size_type nLength = eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - position); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + const size_type n2 = (size_type)CharStrlen(p); + if(EASTL_UNLIKELY((n2 > kMaxSize) || (((size_type)(mpEnd - mpBegin) - nLength) >= (kMaxSize - n2)))) + ThrowLengthException(); + #endif + + return replace(mpBegin + position, mpBegin + position + nLength, p, p + CharStrlen(p)); + } + + + template + basic_string& basic_string::replace(size_type position, size_type n1, size_type n2, value_type c) + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + const size_type nLength = eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - position); + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY((n2 > kMaxSize) || ((size_type)(mpEnd - mpBegin) - nLength) >= (kMaxSize - n2))) + ThrowLengthException(); + #endif + + return replace(mpBegin + position, mpBegin + position + nLength, n2, c); + } + + + template + inline basic_string& basic_string::replace(iterator pBegin, iterator pEnd, const basic_string& x) + { + return replace(pBegin, pEnd, x.mpBegin, x.mpEnd); + } + + + template + inline basic_string& basic_string::replace(iterator pBegin, iterator pEnd, const value_type* p, size_type n) + { + return replace(pBegin, pEnd, p, p + n); + } + + + template + inline basic_string& basic_string::replace(iterator pBegin, iterator pEnd, const value_type* p) + { + return replace(pBegin, pEnd, p, p + CharStrlen(p)); + } + + + template + basic_string& basic_string::replace(iterator pBegin, iterator pEnd, size_type n, value_type c) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((pBegin < mpBegin) || (pBegin > mpEnd) || (pEnd < mpBegin) || (pEnd > mpEnd) || (pEnd < pBegin))) + EASTL_FAIL_MSG("basic_string::replace -- invalid position"); + #endif + + const size_type nLength = static_cast(pEnd - pBegin); + + if(nLength >= n) + { + CharTypeAssignN(pBegin, n, c); + erase(pBegin + n, pEnd); + } + else + { + CharTypeAssignN(pBegin, nLength, c); + insert(pEnd, n - nLength, c); + } + return *this; + } + + + template + basic_string& basic_string::replace(iterator pBegin1, iterator pEnd1, const value_type* pBegin2, const value_type* pEnd2) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((pBegin1 < mpBegin) || (pBegin1 > mpEnd) || (pEnd1 < mpBegin) || (pEnd1 > mpEnd) || (pEnd1 < pBegin1))) + EASTL_FAIL_MSG("basic_string::replace -- invalid position"); + #endif + + const size_type nLength1 = (size_type)(pEnd1 - pBegin1); + const size_type nLength2 = (size_type)(pEnd2 - pBegin2); + + if(nLength1 >= nLength2) // If we have a non-expanding operation... + { + if((pBegin2 > pEnd1) || (pEnd2 <= pBegin1)) // If we have a non-overlapping operation... + memcpy(pBegin1, pBegin2, (size_t)(pEnd2 - pBegin2) * sizeof(value_type)); + else + memmove(pBegin1, pBegin2, (size_t)(pEnd2 - pBegin2) * sizeof(value_type)); + erase(pBegin1 + nLength2, pEnd1); + } + else // Else we are expanding. + { + if((pBegin2 > pEnd1) || (pEnd2 <= pBegin1)) // If we have a non-overlapping operation... + { + const value_type* const pMid2 = pBegin2 + nLength1; + + if((pEnd2 <= pBegin1) || (pBegin2 > pEnd1)) + memcpy(pBegin1, pBegin2, (size_t)(pMid2 - pBegin2) * sizeof(value_type)); + else + memmove(pBegin1, pBegin2, (size_t)(pMid2 - pBegin2) * sizeof(value_type)); + insert(pEnd1, pMid2, pEnd2); + } + else // else we have an overlapping operation. + { + // I can't think of any easy way of doing this without allocating temporary memory. + const size_type nOldSize = (size_type)(mpEnd - mpBegin); + const size_type nOldCap = (size_type)((mpCapacity - mpBegin) - 1); + const size_type nNewCapacity = eastl::max_alt((size_type)GetNewCapacity(nOldCap), (size_type)(nOldSize + (nLength2 - nLength1))) + 1; // + 1 to accomodate the trailing 0. + + pointer pNewBegin = DoAllocate(nNewCapacity); + pointer pNewEnd = pNewBegin; + + pNewEnd = CharStringUninitializedCopy(mpBegin, pBegin1, pNewBegin); + pNewEnd = CharStringUninitializedCopy(pBegin2, pEnd2, pNewEnd); + pNewEnd = CharStringUninitializedCopy(pEnd1, mpEnd, pNewEnd); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + nNewCapacity; + } + } + return *this; + } + + + template + typename basic_string::size_type + basic_string::copy(value_type* p, size_type n, size_type position) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + // It is not clear from the C++ standard if 'p' destination pointer is allowed to + // refer to memory from within the string itself. We assume so and use memmove + // instead of memcpy until we find otherwise. + const size_type nLength = eastl::min_alt(n, (size_type)(mpEnd - mpBegin) - position); + memmove(p, mpBegin + position, (size_t)nLength * sizeof(value_type)); + return nLength; + } + + + template + void basic_string::swap(basic_string& x) + { + if(mAllocator == x.mAllocator) // If allocators are equivalent... + { + // We leave mAllocator as-is. + eastl::swap(mpBegin, x.mpBegin); + eastl::swap(mpEnd, x.mpEnd); + eastl::swap(mpCapacity, x.mpCapacity); + } + else // else swap the contents. + { + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + } + } + + + template + inline typename basic_string::size_type + basic_string::find(const basic_string& x, size_type position) const + { + return find(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::find(const value_type* p, size_type position) const + { + return find(p, position, (size_type)CharStrlen(p)); + } + + + #if defined(EA_PLATFORM_XENON) // If XBox 360... + + template + typename basic_string::size_type + basic_string::find(const value_type* p, size_type position, size_type n) const + { + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(n || (position > nLength)) + { + if(position < nLength) + { + size_type nRemain = nLength - position; + + if(n <= nRemain) + { + nRemain -= (n - 1); + + for(const value_type* p1, *p2 = mpBegin + position; + (p1 = Find(p2, *p, nRemain)) != 0; + nRemain -= (p1 - p2) + 1, p2 = (p1 + 1)) + { + if(Compare(p1, p, n) == 0) + return (size_type)(p1 - mpBegin); + } + } + } + + return npos; + } + + return position; + } + #else + template + typename basic_string::size_type + basic_string::find(const value_type* p, size_type position, size_type n) const + { + // It is not clear what the requirements are for position, but since the C++ standard + // appears to be silent it is assumed for now that position can be any value. + //#if EASTL_ASSERT_ENABLED + // if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + // EASTL_FAIL_MSG("basic_string::find -- invalid position"); + //#endif + + if(EASTL_LIKELY((position + n) <= (size_type)(mpEnd - mpBegin))) // If the range is valid... + { + const value_type* const pTemp = eastl::search(mpBegin + position, mpEnd, p, p + n); + + if((pTemp != mpEnd) || (n == 0)) + return (size_type)(pTemp - mpBegin); + } + return npos; + } + #endif + + + template + typename basic_string::size_type + basic_string::find(value_type c, size_type position) const + { + // It is not clear what the requirements are for position, but since the C++ standard + // appears to be silent it is assumed for now that position can be any value. + //#if EASTL_ASSERT_ENABLED + // if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + // EASTL_FAIL_MSG("basic_string::find -- invalid position"); + //#endif + + if(EASTL_LIKELY(position < (size_type)(mpEnd - mpBegin))) // If the position is valid... + { + const const_iterator pResult = eastl::find(mpBegin + position, mpEnd, c); + + if(pResult != mpEnd) + return (size_type)(pResult - mpBegin); + } + return npos; + } + + + template + inline typename basic_string::size_type + basic_string::rfind(const basic_string& x, size_type position) const + { + return rfind(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::rfind(const value_type* p, size_type position) const + { + return rfind(p, position, (size_type)CharStrlen(p)); + } + + + template + typename basic_string::size_type + basic_string::rfind(const value_type* p, size_type position, size_type n) const + { + // Disabled because it's not clear what values are valid for position. + // It is documented that npos is a valid value, though. We return npos and + // don't crash if postion is any invalid value. + //#if EASTL_ASSERT_ENABLED + // if(EASTL_UNLIKELY((position != npos) && (position > (size_type)(mpEnd - mpBegin)))) + // EASTL_FAIL_MSG("basic_string::rfind -- invalid position"); + //#endif + + // Note that a search for a zero length string starting at position = end() returns end() and not npos. + // Note by Paul Pedriana: I am not sure how this should behave in the case of n == 0 and position > size. + // The standard seems to suggest that rfind doesn't act exactly the same as find in that input position + // can be > size and the return value can still be other than npos. Thus, if n == 0 then you can + // never return npos, unlike the case with find. + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(EASTL_LIKELY(n <= nLength)) + { + if(EASTL_LIKELY(n)) + { + const const_iterator pEnd = mpBegin + eastl::min_alt(nLength - n, position) + n; + const const_iterator pResult = CharTypeStringRSearch(mpBegin, pEnd, p, p + n); + + if(pResult != pEnd) + return (size_type)(pResult - mpBegin); + } + else + return eastl::min_alt(nLength, position); + } + return npos; + } + + + template + typename basic_string::size_type + basic_string::rfind(value_type c, size_type position) const + { + // If n is zero or position is >= size, we return npos. + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(EASTL_LIKELY(nLength)) + { + const value_type* const pEnd = mpBegin + eastl::min_alt(nLength - 1, position) + 1; + const value_type* const pResult = CharTypeStringRFind(pEnd, mpBegin, c); + + if(pResult != mpBegin) + return (size_type)((pResult - 1) - mpBegin); + } + return npos; + } + + + template + inline typename basic_string::size_type + basic_string::find_first_of(const basic_string& x, size_type position) const + { + return find_first_of(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::find_first_of(const value_type* p, size_type position) const + { + return find_first_of(p, position, (size_type)CharStrlen(p)); + } + + + #if defined(EA_PLATFORM_XENON) // If XBox 360... + + template + typename basic_string::size_type + basic_string::find_first_of(const value_type* p, size_type position, size_type n) const + { + // If position is >= size, we return npos. + if(n && (position < (size_type)(mpEnd - mpBegin))) + { + for(const value_type* p1 = (mpBegin + position); p1 < mpEnd; ++p1) + { + if(Find(p, *p1, n) != 0) + return (size_type)(p1 - mpBegin); + } + } + return npos; + } + #else + template + typename basic_string::size_type + basic_string::find_first_of(const value_type* p, size_type position, size_type n) const + { + // If position is >= size, we return npos. + if(EASTL_LIKELY((position < (size_type)(mpEnd - mpBegin)))) + { + const value_type* const pBegin = mpBegin + position; + const const_iterator pResult = CharTypeStringFindFirstOf(pBegin, mpEnd, p, p + n); + + if(pResult != mpEnd) + return (size_type)(pResult - mpBegin); + } + return npos; + } + #endif + + + template + inline typename basic_string::size_type + basic_string::find_first_of(value_type c, size_type position) const + { + return find(c, position); + } + + + template + inline typename basic_string::size_type + basic_string::find_last_of(const basic_string& x, size_type position) const + { + return find_last_of(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::find_last_of(const value_type* p, size_type position) const + { + return find_last_of(p, position, (size_type)CharStrlen(p)); + } + + + #if defined(EA_PLATFORM_XENON) // If XBox 360... + + template + typename basic_string::size_type + basic_string::find_last_of(const value_type* p, size_type position, size_type n) const + { + // If n is zero or position is >= size, we return npos. + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(n && nLength) + { + const value_type* p1; + + if(position < nLength) + p1 = mpBegin + position; + else + p1 = mpEnd - 1; + + for(;;) + { + if(Find(p, *p1, n)) + return (size_type)(p1 - mpBegin); + + if(p1-- == mpBegin) + break; + } + } + + return npos; + } + #else + template + typename basic_string::size_type + basic_string::find_last_of(const value_type* p, size_type position, size_type n) const + { + // If n is zero or position is >= size, we return npos. + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(EASTL_LIKELY(nLength)) + { + const value_type* const pEnd = mpBegin + eastl::min_alt(nLength - 1, position) + 1; + const value_type* const pResult = CharTypeStringRFindFirstOf(pEnd, mpBegin, p, p + n); + + if(pResult != mpBegin) + return (size_type)((pResult - 1) - mpBegin); + } + return npos; + } + #endif + + + template + inline typename basic_string::size_type + basic_string::find_last_of(value_type c, size_type position) const + { + return rfind(c, position); + } + + + template + inline typename basic_string::size_type + basic_string::find_first_not_of(const basic_string& x, size_type position) const + { + return find_first_not_of(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::find_first_not_of(const value_type* p, size_type position) const + { + return find_first_not_of(p, position, (size_type)CharStrlen(p)); + } + + + template + typename basic_string::size_type + basic_string::find_first_not_of(const value_type* p, size_type position, size_type n) const + { + if(EASTL_LIKELY(position <= (size_type)(mpEnd - mpBegin))) + { + const const_iterator pResult = CharTypeStringFindFirstNotOf(mpBegin + position, mpEnd, p, p + n); + + if(pResult != mpEnd) + return (size_type)(pResult - mpBegin); + } + return npos; + } + + + template + typename basic_string::size_type + basic_string::find_first_not_of(value_type c, size_type position) const + { + if(EASTL_LIKELY(position <= (size_type)(mpEnd - mpBegin))) + { + // Todo: Possibly make a specialized version of CharTypeStringFindFirstNotOf(pBegin, pEnd, c). + const const_iterator pResult = CharTypeStringFindFirstNotOf(mpBegin + position, mpEnd, &c, &c + 1); + + if(pResult != mpEnd) + return (size_type)(pResult - mpBegin); + } + return npos; + } + + + template + inline typename basic_string::size_type + basic_string::find_last_not_of(const basic_string& x, size_type position) const + { + return find_last_not_of(x.mpBegin, position, (size_type)(x.mpEnd - x.mpBegin)); + } + + + template + inline typename basic_string::size_type + basic_string::find_last_not_of(const value_type* p, size_type position) const + { + return find_last_not_of(p, position, (size_type)CharStrlen(p)); + } + + + template + typename basic_string::size_type + basic_string::find_last_not_of(const value_type* p, size_type position, size_type n) const + { + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(EASTL_LIKELY(nLength)) + { + const value_type* const pEnd = mpBegin + eastl::min_alt(nLength - 1, position) + 1; + const value_type* const pResult = CharTypeStringRFindFirstNotOf(pEnd, mpBegin, p, p + n); + + if(pResult != mpBegin) + return (size_type)((pResult - 1) - mpBegin); + } + return npos; + } + + + template + typename basic_string::size_type + basic_string::find_last_not_of(value_type c, size_type position) const + { + const size_type nLength = (size_type)(mpEnd - mpBegin); + + if(EASTL_LIKELY(nLength)) + { + // Todo: Possibly make a specialized version of CharTypeStringRFindFirstNotOf(pBegin, pEnd, c). + const value_type* const pEnd = mpBegin + eastl::min_alt(nLength - 1, position) + 1; + const value_type* const pResult = CharTypeStringRFindFirstNotOf(pEnd, mpBegin, &c, &c + 1); + + if(pResult != mpBegin) + return (size_type)((pResult - 1) - mpBegin); + } + return npos; + } + + + template + inline basic_string basic_string::substr(size_type position, size_type n) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(position > (size_type)(mpEnd - mpBegin))) + EASTL_FAIL_MSG("basic_string::substr -- invalid position"); + #endif + + return basic_string(mpBegin + position, mpBegin + position + eastl::min_alt(n, (size_type)(mpEnd - mpBegin) - position), mAllocator); + } + + + template + inline int basic_string::compare(const basic_string& x) const + { + return compare(mpBegin, mpEnd, x.mpBegin, x.mpEnd); + } + + + template + inline int basic_string::compare(size_type pos1, size_type n1, const basic_string& x) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(pos1 > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + return compare(mpBegin + pos1, + mpBegin + pos1 + eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - pos1), + x.mpBegin, + x.mpEnd); + } + + + template + inline int basic_string::compare(size_type pos1, size_type n1, const basic_string& x, size_type pos2, size_type n2) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY((pos1 > (size_type)(mpEnd - mpBegin)) || (pos2 > (size_type)(x.mpEnd - x.mpBegin)))) + ThrowRangeException(); + #endif + + return compare(mpBegin + pos1, + mpBegin + pos1 + eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - pos1), + x.mpBegin + pos2, + x.mpBegin + pos2 + eastl::min_alt(n2, (size_type)(mpEnd - mpBegin) - pos2)); + } + + + template + inline int basic_string::compare(const value_type* p) const + { + return compare(mpBegin, mpEnd, p, p + CharStrlen(p)); + } + + + template + inline int basic_string::compare(size_type pos1, size_type n1, const value_type* p) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(pos1 > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + return compare(mpBegin + pos1, + mpBegin + pos1 + eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - pos1), + p, + p + CharStrlen(p)); + } + + + template + inline int basic_string::compare(size_type pos1, size_type n1, const value_type* p, size_type n2) const + { + #if EASTL_STRING_OPT_RANGE_ERRORS + if(EASTL_UNLIKELY(pos1 > (size_type)(mpEnd - mpBegin))) + ThrowRangeException(); + #endif + + return compare(mpBegin + pos1, + mpBegin + pos1 + eastl::min_alt(n1, (size_type)(mpEnd - mpBegin) - pos1), + p, + p + n2); + } + + + // make_lower + // This is a very simple ASCII-only case conversion function + // Anything more complicated should use a more powerful separate library. + template + inline void basic_string::make_lower() + { + for(pointer p = mpBegin; p < mpEnd; ++p) + *p = (value_type)CharToLower(*p); + } + + + // make_upper + // This is a very simple ASCII-only case conversion function + // Anything more complicated should use a more powerful separate library. + template + inline void basic_string::make_upper() + { + for(pointer p = mpBegin; p < mpEnd; ++p) + *p = (value_type)CharToUpper(*p); + } + + + template + inline void basic_string::ltrim() + { + const value_type array[] = { ' ', '\t', 0 }; // This is a pretty simplistic view of whitespace. + erase(0, find_first_not_of(array)); + } + + + template + inline void basic_string::rtrim() + { + const value_type array[] = { ' ', '\t', 0 }; // This is a pretty simplistic view of whitespace. + erase(find_last_not_of(array) + 1); + } + + + template + inline void basic_string::trim() + { + ltrim(); + rtrim(); + } + + + template + inline basic_string basic_string::left(size_type n) const + { + const size_type nLength = length(); + if(n < nLength) + return substr(0, n); + return *this; + } + + + template + inline basic_string basic_string::right(size_type n) const + { + const size_type nLength = length(); + if(n < nLength) + return substr(nLength - n, n); + return *this; + } + + + template + inline basic_string& basic_string::sprintf(const value_type* pFormat, ...) + { + va_list arguments; + va_start(arguments, pFormat); + mpEnd = mpBegin; // Fast truncate to zero length. + append_sprintf_va_list(pFormat, arguments); + va_end(arguments); + + return *this; + } + + + template + basic_string& basic_string::sprintf_va_list(const value_type* pFormat, va_list arguments) + { + mpEnd = mpBegin; // Fast truncate to zero length. + + return append_sprintf_va_list(pFormat, arguments); + } + + + template + int basic_string::compare(const value_type* pBegin1, const value_type* pEnd1, + const value_type* pBegin2, const value_type* pEnd2) + { + const ptrdiff_t n1 = pEnd1 - pBegin1; + const ptrdiff_t n2 = pEnd2 - pBegin2; + const ptrdiff_t nMin = eastl::min_alt(n1, n2); + const int cmp = Compare(pBegin1, pBegin2, (size_t)nMin); + + return (cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0))); + } + + + template + int basic_string::comparei(const value_type* pBegin1, const value_type* pEnd1, + const value_type* pBegin2, const value_type* pEnd2) + { + const ptrdiff_t n1 = pEnd1 - pBegin1; + const ptrdiff_t n2 = pEnd2 - pBegin2; + const ptrdiff_t nMin = eastl::min_alt(n1, n2); + const int cmp = CompareI(pBegin1, pBegin2, (size_t)nMin); + + return (cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0))); + } + + + template + inline int basic_string::comparei(const basic_string& x) const + { + return comparei(mpBegin, mpEnd, x.mpBegin, x.mpEnd); + } + + + template + inline int basic_string::comparei(const value_type* p) const + { + return comparei(mpBegin, mpEnd, p, p + CharStrlen(p)); + } + + + template + typename basic_string::iterator + basic_string::InsertInternal(iterator p, value_type c) + { + iterator pNewPosition = p; + + if((mpEnd + 1) < mpCapacity) + { + *(mpEnd + 1) = 0; + memmove(p + 1, p, (size_t)(mpEnd - p) * sizeof(value_type)); + *p = c; + ++mpEnd; + } + else + { + const size_type nOldSize = (size_type)(mpEnd - mpBegin); + const size_type nOldCap = (size_type)((mpCapacity - mpBegin) - 1); + const size_type nLength = eastl::max_alt((size_type)GetNewCapacity(nOldCap), (size_type)(nOldSize + 1)) + 1; // The second + 1 is to accomodate the trailing 0. + + iterator pNewBegin = DoAllocate(nLength); + iterator pNewEnd = pNewBegin; + + pNewPosition = CharStringUninitializedCopy(mpBegin, p, pNewBegin); + *pNewPosition = c; + + pNewEnd = pNewPosition + 1; + pNewEnd = CharStringUninitializedCopy(p, mpEnd, pNewEnd); + *pNewEnd = 0; + + DeallocateSelf(); + mpBegin = pNewBegin; + mpEnd = pNewEnd; + mpCapacity = pNewBegin + nLength; + } + return pNewPosition; + } + + + template + void basic_string::SizeInitialize(size_type n, value_type c) + { + AllocateSelf((size_type)(n + 1)); // '+1' so that we have room for the terminating 0. + + mpEnd = CharStringUninitializedFillN(mpBegin, n, c); + *mpEnd = 0; + } + + + template + void basic_string::RangeInitialize(const value_type* pBegin, const value_type* pEnd) + { + const size_type n = (size_type)(pEnd - pBegin); + + #if EASTL_STRING_OPT_ARGUMENT_ERRORS + if(EASTL_UNLIKELY(!pBegin && (n != 0))) + ThrowInvalidArgumentException(); + #endif + + AllocateSelf((size_type)(n + 1)); // '+1' so that we have room for the terminating 0. + + mpEnd = CharStringUninitializedCopy(pBegin, pEnd, mpBegin); + *mpEnd = 0; + } + + + template + inline void basic_string::RangeInitialize(const value_type* pBegin) + { + #if EASTL_STRING_OPT_ARGUMENT_ERRORS + if(EASTL_UNLIKELY(!pBegin)) + ThrowInvalidArgumentException(); + #endif + + RangeInitialize(pBegin, pBegin + CharStrlen(pBegin)); + } + + + template + inline typename basic_string::value_type* + basic_string::DoAllocate(size_type n) + { + EASTL_ASSERT(n > 1); // We want n > 1 because n == 1 is reserved for empty capacity and usage of gEmptyString. + return (value_type*)EASTLAlloc(mAllocator, n * sizeof(value_type)); + } + + + template + inline void basic_string::DoFree(value_type* p, size_type n) + { + if(p) + EASTLFree(mAllocator, p, n * sizeof(value_type)); + } + + + template + inline typename basic_string::size_type + basic_string::GetNewCapacity(size_type currentCapacity) // This needs to return a value of at least currentCapacity and at least 1. + { + return (currentCapacity > EASTL_STRING_INITIAL_CAPACITY) ? (2 * currentCapacity) : EASTL_STRING_INITIAL_CAPACITY; + } + + + template + inline void basic_string::AllocateSelf() + { + EASTL_ASSERT(gEmptyString.mUint32 == 0); + mpBegin = const_cast(GetEmptyString(value_type())); // In const_cast-int this, we promise not to modify it. + mpEnd = mpBegin; + mpCapacity = mpBegin + 1; // When we are using gEmptyString, mpCapacity is always mpEnd + 1. This is an important distinguising characteristic. + } + + + template + void basic_string::AllocateSelf(size_type n) + { + #if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= 0x40000000)) + EASTL_FAIL_MSG("basic_string::AllocateSelf -- improbably large request."); + #endif + + #if EASTL_STRING_OPT_LENGTH_ERRORS + if(EASTL_UNLIKELY(n > kMaxSize)) + ThrowLengthException(); + #endif + + if(n > 1) + { + mpBegin = DoAllocate(n); + mpEnd = mpBegin; + mpCapacity = mpBegin + n; + } + else + AllocateSelf(); + } + + + template + inline void basic_string::DeallocateSelf() + { + // Note that we compare mpCapacity to mpEnd instead of comparing + // mpBegin to &gEmptyString. This is important because we may have + // a case whereby one library passes a string to another library to + // deallocate and the two libraries have idependent versions of gEmptyString. + if((mpCapacity - mpBegin) > 1) // If we are not using gEmptyString as our memory... + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + } + + + template + inline void basic_string::ThrowLengthException() const + { + #if EASTL_EXCEPTIONS_ENABLED + throw std::length_error("basic_string -- length_error"); + #elif EASTL_ASSERT_ENABLED + EASTL_FAIL_MSG("basic_string -- length_error"); + #endif + } + + + template + inline void basic_string::ThrowRangeException() const + { + #if EASTL_EXCEPTIONS_ENABLED + throw std::out_of_range("basic_string -- out of range"); + #elif EASTL_ASSERT_ENABLED + EASTL_FAIL_MSG("basic_string -- out of range"); + #endif + } + + + template + inline void basic_string::ThrowInvalidArgumentException() const + { + #if EASTL_EXCEPTIONS_ENABLED + throw std::invalid_argument("basic_string -- invalid argument"); + #elif EASTL_ASSERT_ENABLED + EASTL_FAIL_MSG("basic_string -- invalid argument"); + #endif + } + + + // CharTypeStringFindEnd + // Specialized char version of STL find() from back function. + // Not the same as RFind because search range is specified as forward iterators. + template + const typename basic_string::value_type* + basic_string::CharTypeStringFindEnd(const value_type* pBegin, const value_type* pEnd, value_type c) + { + const value_type* pTemp = pEnd; + while(--pTemp >= pBegin) + { + if(*pTemp == c) + return pTemp; + } + + return pEnd; + } + + + // CharTypeStringRFind + // Specialized value_type version of STL find() function in reverse. + template + const typename basic_string::value_type* + basic_string::CharTypeStringRFind(const value_type* pRBegin, const value_type* pREnd, const value_type c) + { + while(pRBegin > pREnd) + { + if(*(pRBegin - 1) == c) + return pRBegin; + --pRBegin; + } + return pREnd; + } + + + // CharTypeStringSearch + // Specialized value_type version of STL search() function. + // Purpose: find p2 within p1. Return p1End if not found or if either string is zero length. + template + const typename basic_string::value_type* + basic_string::CharTypeStringSearch(const value_type* p1Begin, const value_type* p1End, + const value_type* p2Begin, const value_type* p2End) + { + // Test for zero length strings, in which case we have a match or a failure, + // but the return value is the same either way. + if((p1Begin == p1End) || (p2Begin == p2End)) + return p1Begin; + + // Test for a pattern of length 1. + if((p2Begin + 1) == p2End) + return eastl::find(p1Begin, p1End, *p2Begin); + + // General case. + const value_type* pTemp; + const value_type* pTemp1 = (p2Begin + 1); + const value_type* pCurrent = p1Begin; + + while(p1Begin != p1End) + { + p1Begin = eastl::find(p1Begin, p1End, *p2Begin); + if(p1Begin == p1End) + return p1End; + + pTemp = pTemp1; + pCurrent = p1Begin; + if(++pCurrent == p1End) + return p1End; + + while(*pCurrent == *pTemp) + { + if(++pTemp == p2End) + return p1Begin; + if(++pCurrent == p1End) + return p1End; + } + + ++p1Begin; + } + + return p1Begin; + } + + + // CharTypeStringRSearch + // Specialized value_type version of STL find_end() function (which really is a reverse search function). + // Purpose: find last instance of p2 within p1. Return p1End if not found or if either string is zero length. + template + const typename basic_string::value_type* + basic_string::CharTypeStringRSearch(const value_type* p1Begin, const value_type* p1End, + const value_type* p2Begin, const value_type* p2End) + { + // Test for zero length strings, in which case we have a match or a failure, + // but the return value is the same either way. + if((p1Begin == p1End) || (p2Begin == p2End)) + return p1Begin; + + // Test for a pattern of length 1. + if((p2Begin + 1) == p2End) + return CharTypeStringFindEnd(p1Begin, p1End, *p2Begin); + + // Test for search string length being longer than string length. + if((p2End - p2Begin) > (p1End - p1Begin)) + return p1End; + + // General case. + const value_type* pSearchEnd = (p1End - (p2End - p2Begin) + 1); + const value_type* pCurrent1; + const value_type* pCurrent2; + + while(pSearchEnd != p1Begin) + { + // Search for the last occurrence of *p2Begin. + pCurrent1 = CharTypeStringFindEnd(p1Begin, pSearchEnd, *p2Begin); + if(pCurrent1 == pSearchEnd) // If the first char of p2 wasn't found, + return p1End; // then we immediately have failure. + + // In this case, *pTemp == *p2Begin. So compare the rest. + pCurrent2 = p2Begin; + while(*pCurrent1++ == *pCurrent2++) + { + if(pCurrent2 == p2End) + return (pCurrent1 - (p2End - p2Begin)); + } + + // A smarter algorithm might know to subtract more than just one, + // but in most cases it won't make much difference anyway. + --pSearchEnd; + } + + return p1End; + } + + + // CharTypeStringFindFirstOf + // Specialized value_type version of STL find_first_of() function. + // This function is much like the C runtime strtok function, except the strings aren't null-terminated. + template + const typename basic_string::value_type* + basic_string::CharTypeStringFindFirstOf(const value_type* p1Begin, const value_type* p1End, + const value_type* p2Begin, const value_type* p2End) + { + for( ; p1Begin != p1End; ++p1Begin) + { + for(const value_type* pTemp = p2Begin; pTemp != p2End; ++pTemp) + { + if(*p1Begin == *pTemp) + return p1Begin; + } + } + return p1End; + } + + + // CharTypeStringRFindFirstOf + // Specialized value_type version of STL find_first_of() function in reverse. + // This function is much like the C runtime strtok function, except the strings aren't null-terminated. + template + const typename basic_string::value_type* + basic_string::CharTypeStringRFindFirstOf(const value_type* p1RBegin, const value_type* p1REnd, + const value_type* p2Begin, const value_type* p2End) + { + for( ; p1RBegin != p1REnd; --p1RBegin) + { + for(const value_type* pTemp = p2Begin; pTemp != p2End; ++pTemp) + { + if(*(p1RBegin - 1) == *pTemp) + return p1RBegin; + } + } + return p1REnd; + } + + + + // CharTypeStringFindFirstNotOf + // Specialized value_type version of STL find_first_not_of() function. + template + const typename basic_string::value_type* + basic_string::CharTypeStringFindFirstNotOf(const value_type* p1Begin, const value_type* p1End, + const value_type* p2Begin, const value_type* p2End) + { + for( ; p1Begin != p1End; ++p1Begin) + { + const value_type* pTemp; + for(pTemp = p2Begin; pTemp != p2End; ++pTemp) + { + if(*p1Begin == *pTemp) + break; + } + if(pTemp == p2End) + return p1Begin; + } + return p1End; + } + + + // CharTypeStringRFindFirstNotOf + // Specialized value_type version of STL find_first_not_of() function in reverse. + template + const typename basic_string::value_type* + basic_string::CharTypeStringRFindFirstNotOf(const value_type* p1RBegin, const value_type* p1REnd, + const value_type* p2Begin, const value_type* p2End) + { + for( ; p1RBegin != p1REnd; --p1RBegin) + { + const value_type* pTemp; + for(pTemp = p2Begin; pTemp != p2End; ++pTemp) + { + if(*(p1RBegin-1) == *pTemp) + break; + } + if(pTemp == p2End) + return p1RBegin; + } + return p1REnd; + } + + + + + // iterator operators + template + inline bool operator==(const typename basic_string::reverse_iterator& r1, + const typename basic_string::reverse_iterator& r2) + { + return r1.mpCurrent == r2.mpCurrent; + } + + + template + inline bool operator!=(const typename basic_string::reverse_iterator& r1, + const typename basic_string::reverse_iterator& r2) + { + return r1.mpCurrent != r2.mpCurrent; + } + + + // Operator + + template + basic_string operator+(const basic_string& a, const basic_string& b) + { + typedef typename basic_string::CtorDoNotInitialize CtorDoNotInitialize; + CtorDoNotInitialize cDNI; // GCC 2.x forces us to declare a named temporary like this. + basic_string result(cDNI, a.size() + b.size(), const_cast&>(a).get_allocator()); // Note that we choose to assign a's allocator. + result.append(a); + result.append(b); + return result; + } + + + template + basic_string operator+(const typename basic_string::value_type* p, const basic_string& b) + { + typedef typename basic_string::CtorDoNotInitialize CtorDoNotInitialize; + CtorDoNotInitialize cDNI; // GCC 2.x forces us to declare a named temporary like this. + const typename basic_string::size_type n = (typename basic_string::size_type)CharStrlen(p); + basic_string result(cDNI, n + b.size(), const_cast&>(b).get_allocator()); + result.append(p, p + n); + result.append(b); + return result; + } + + + template + basic_string operator+(typename basic_string::value_type c, const basic_string& b) + { + typedef typename basic_string::CtorDoNotInitialize CtorDoNotInitialize; + CtorDoNotInitialize cDNI; // GCC 2.x forces us to declare a named temporary like this. + basic_string result(cDNI, 1 + b.size(), const_cast&>(b).get_allocator()); + result.push_back(c); + result.append(b); + return result; + } + + + template + basic_string operator+(const basic_string& a, const typename basic_string::value_type* p) + { + typedef typename basic_string::CtorDoNotInitialize CtorDoNotInitialize; + CtorDoNotInitialize cDNI; // GCC 2.x forces us to declare a named temporary like this. + const typename basic_string::size_type n = (typename basic_string::size_type)CharStrlen(p); + basic_string result(cDNI, a.size() + n, const_cast&>(a).get_allocator()); + result.append(a); + result.append(p, p + n); + return result; + } + + + template + basic_string operator+(const basic_string& a, const typename basic_string::value_type c) + { + typedef typename basic_string::CtorDoNotInitialize CtorDoNotInitialize; + CtorDoNotInitialize cDNI; // GCC 2.x forces us to declare a named temporary like this. + basic_string result(cDNI, a.size() + 1, const_cast&>(a).get_allocator()); + result.append(a); + result.push_back(c); + return result; + } + + + template + inline bool basic_string::validate() const + { + if((mpBegin == NULL) || (mpEnd == NULL)) + return false; + if(mpEnd < mpBegin) + return false; + if(mpCapacity < mpEnd) + return false; + return true; + } + + + template + inline int basic_string::validate_iterator(const_iterator i) const + { + if(i >= mpBegin) + { + if(i < mpEnd) + return (isf_valid | isf_current | isf_can_dereference); + + if(i <= mpEnd) + return (isf_valid | isf_current); + } + + return isf_none; + } + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + // Operator== and operator!= + template + inline bool operator==(const basic_string& a, const basic_string& b) + { + return ((a.size() == b.size()) && (memcmp(a.data(), b.data(), (size_t)a.size() * sizeof(typename basic_string::value_type)) == 0)); + } + + + template + inline bool operator==(const typename basic_string::value_type* p, const basic_string& b) + { + typedef typename basic_string::size_type size_type; + const size_type n = (size_type)CharStrlen(p); + return ((n == b.size()) && (memcmp(p, b.data(), (size_t)n * sizeof(*p)) == 0)); + } + + + template + inline bool operator==(const basic_string& a, const typename basic_string::value_type* p) + { + typedef typename basic_string::size_type size_type; + const size_type n = (size_type)CharStrlen(p); + return ((a.size() == n) && (memcmp(a.data(), p, (size_t)n * sizeof(*p)) == 0)); + } + + + template + inline bool operator!=(const basic_string& a, const basic_string& b) + { + return !(a == b); + } + + + template + inline bool operator!=(const typename basic_string::value_type* p, const basic_string& b) + { + return !(p == b); + } + + + template + inline bool operator!=(const basic_string& a, const typename basic_string::value_type* p) + { + return !(a == p); + } + + + // Operator< (and also >, <=, and >=). + template + inline bool operator<(const basic_string& a, const basic_string& b) + { + return basic_string::compare(a.begin(), a.end(), b.begin(), b.end()) < 0; } + + + template + inline bool operator<(const typename basic_string::value_type* p, const basic_string& b) + { + typedef typename basic_string::size_type size_type; + const size_type n = (size_type)CharStrlen(p); + return basic_string::compare(p, p + n, b.begin(), b.end()) < 0; + } + + + template + inline bool operator<(const basic_string& a, const typename basic_string::value_type* p) + { + typedef typename basic_string::size_type size_type; + const size_type n = (size_type)CharStrlen(p); + return basic_string::compare(a.begin(), a.end(), p, p + n) < 0; + } + + + template + inline bool operator>(const basic_string& a, const basic_string& b) + { + return b < a; + } + + + template + inline bool operator>(const typename basic_string::value_type* p, const basic_string& b) + { + return b < p; + } + + + template + inline bool operator>(const basic_string& a, const typename basic_string::value_type* p) + { + return p < a; + } + + + template + inline bool operator<=(const basic_string& a, const basic_string& b) + { + return !(b < a); + } + + + template + inline bool operator<=(const typename basic_string::value_type* p, const basic_string& b) + { + return !(b < p); + } + + + template + inline bool operator<=(const basic_string& a, const typename basic_string::value_type* p) + { + return !(p < a); + } + + + template + inline bool operator>=(const basic_string& a, const basic_string& b) + { + return !(a < b); + } + + + template + inline bool operator>=(const typename basic_string::value_type* p, const basic_string& b) + { + return !(p < b); + } + + + template + inline bool operator>=(const basic_string& a, const typename basic_string::value_type* p) + { + return !(a < p); + } + + + template + inline void swap(basic_string& a, basic_string& b) + { + a.swap(b); + } + + + /// string / wstring + typedef basic_string string; + typedef basic_string wstring; + + /// string8 / string16 / string32 + typedef basic_string string8; + typedef basic_string string16; + typedef basic_string string32; + + + + /// hash + /// + /// We provide EASTL hash function objects for use in hash table containers. + /// + /// Example usage: + /// #include + /// hash_set stringHashSet; + /// + template struct hash; + + template <> + struct hash + { + size_t operator()(const string& x) const + { + const unsigned char* p = (const unsigned char*)x.c_str(); // To consider: limit p to at most 256 chars. + unsigned int c, result = 2166136261U; // We implement an FNV-like string hash. + while((c = *p++) != 0) // Using '!=' disables compiler warnings. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + /// hash + /// + template <> + struct hash + { + size_t operator()(const wstring& x) const + { + const wchar_t* p = (const wchar_t*)x.c_str(); // To consider: limit p to at most 256 chars. + unsigned int c, result = 2166136261U; // We implement an FNV-like string hash. + while((c = *p++) != 0) // Using '!=' disables compiler warnings. + result = (result * 16777619) ^ c; + return (size_t)result; + } + }; + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +#endif // EASTL_ABSTRACT_STRING_ENABLED + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/type_traits.h b/lib/eastl/include/EASTL/type_traits.h new file mode 100644 index 0000000..42b6c34 --- /dev/null +++ b/lib/eastl/include/EASTL/type_traits.h @@ -0,0 +1,359 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/type_traits.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Specification +// +// This file implements C++ type traits as proposed by the emerging C++ update +// as of May, 2005. This update is known as "Proposed Draft Technical Report +// on C++ Library Extensions" and is document number n1745. It can be found +// on the Internet as n1745.pdf and as of this writing it is updated every +// couple months to reflect current thinking. +////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Description +// +// EASTL includes a fairly serious type traits library that is on par with the +// one found in Boost but offers some additional performance-enhancing help as well. +// The type_traits library provides information about class types, as opposed to +// class instances. For example, the is_integral type trait tells if a type is +// one of int, short, long, char, uint64_t, etc. +// +// There are three primary uses of type traits: +// * Allowing for optimized operations on some data types. +// * Allowing for different logic pathways based on data types. +// * Allowing for compile-type assertions about data type expectations. +// +// Most of the type traits are automatically detected and implemented by the compiler. +// However, EASTL allows for the user to explicitly give the compiler hints about +// type traits that the compiler cannot know, via the EASTL_DECLARE declarations. +// If the user has a class that is relocatable (i.e. can safely use memcpy to copy values), +// the user can use the EASTL_DECLARE_TRIVIAL_RELOCATE declaration to tell the compiler +// that the class can be copied via memcpy. This will automatically significantly speed +// up some containers and algorithms that use that class. +// +// Here is an example of using type traits to tell if a value is a floating point +// value or not: +// +// template +// DoSomething(T t) { +// assert(is_floating_point::value); +// } +// +// Here is an example of declaring a class as relocatable and using it in a vector. +// +// EASTL_DECLARE_TRIVIAL_RELOCATE(Widget); // Usually you put this at the Widget class declaration. +// vector wVector; +// wVector.erase(wVector.begin()); // This operation will be optimized via using memcpy. +// +// The following is a full list of the currently recognized type traits. Most of these +// are implemented as of this writing, but if there is one that is missing, feel free +// to contact the maintainer of this library and request that it be completed. +// +// Trait Description +// ------------------------------------------------------------------------------ +// is_void T is void or a cv-qualified (const/void-qualified) void. +// is_integral T is an integral type. +// is_floating_point T is a floating point type. +// is_arithmetic T is an arithmetic type (integral or floating point). +// is_fundamental T is a fundamental type (void, integral, or floating point). +// is_const T is const-qualified. +// is_volatile T is volatile-qualified. +// is_abstract T is an abstract class. +// is_signed T is a signed integral type. +// is_unsigned T is an unsigned integral type. +// is_array T is an array type. The templated array container is not an array type. +// is_pointer T is a pointer type. Includes function pointers, but not pointers to (data or function) members. +// is_reference T is a reference type. Includes references to functions. +// is_member_object_pointer T is a pointer to data member. +// is_member_function_pointer T is a pointer to member function. +// is_member_pointer T is a pointer to a member or member function. +// is_enum T is an enumeration type. +// is_union T is a union type. +// is_class T is a class type but not a union type. +// is_polymorphic T is a polymorphic class. +// is_function T is a function type. +// is_object T is an object type. +// is_scalar T is a scalar type (arithmetic, enum, pointer, member_pointer) +// is_compound T is a compound type (anything but fundamental). +// is_same T and U name the same type. +// is_convertible An imaginary lvalue of type From is implicitly convertible to type To. Special conversions involving string-literals and null-pointer constants are not considered. No function-parameter adjustments are made to type To when determining whether From is convertible to To; this implies that if type To is a function type or an array type, then the condition is false. +// is_base_of Base is a base class of Derived or Base and Derived name the same type. +// is_empty T is an empty class. +// is_pod T is a POD type. +// *is_aligned Defined as true if the type has alignment requirements greater than default alignment, which is taken to be 8. +// has_trivial_constructor The default constructor for T is trivial. +// has_trivial_copy The copy constructor for T is trivial. +// has_trivial_assign The assignment operator for T is trivial. +// has_trivial_destructor The destructor for T is trivial. +// *has_trivial_relocate T can be moved to a new location via bitwise copy. +// has_nothrow_constructor The default constructor for T has an empty exception specification or can otherwise be deduced never to throw an exception. +// has_nothrow_copy The copy constructor for T has an empty exception specification or can otherwise be deduced never to throw an exception. +// has_nothrow_assign The assignment operator for T has an empty exception specification or can otherwise be deduced never to throw an exception. +// has_virtual_destructor T has a virtual destructor. +// alignment_of An integer value representing the number of bytes of the alignment of objects of type T; an object of type T may be allocated at an address that is a multiple of its alignment. +// rank An integer value representing the rank of objects of type T. The term 'rank' here is used to describe the number of dimensions of an array type. +// extent An integer value representing the extent (dimension) of the I'th bound of objects of type T. If the type T is not an array type, has rank of less than I, or if I == 0 and T is of type 'array of unknown bound of U,' then value shall evaluate to zero; otherwise value shall evaluate to the number of elements in the I'th array bound of T. The term 'extent' here is used to describe the number of elements in an array type. +// remove_const The member typedef type shall be the same as T except that any top level const-qualifier has been removed. remove_const::type evaluates to volatile int, whereas remove_const is const int*. +// +// * is_aligned is not found in Boost nor the C++ standard update proposal. +// +// * has_trivial_relocate is not found in Boost nor the C++ standard update proposal. +// However, it is very useful in allowing for the generation of optimized object +// moving operations. It is similar to the is_pod type trait, but goes further and +// allows non-pod classes to be categorized as relocatable. Such categorization is +// something that no compiler can do, as only the user can know if it is such. +// Thus EASTL_DECLARE_TRIVIAL_RELOCATE is provided to allow the user to give +// the compiler a hint. +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Requirements +// +// As of this writing (5/2005), type_traits here requires a well-conforming +// C++ compiler with respect to template metaprogramming. To use this library +// you need to have at least one of the following: +// MSVC++ 7.1 (includes Win32, XBox 360, Win64, and WinCE platforms) +// GCC 3.2 (includes Playstation 3, and Linux platforms) +// Metrowerks 8.0 (incluees Playstation 3, Windows, and other platforms) +// SN Systems (not the GCC 2.95-based compilers) +// EDG (includes any compiler with EDG as a back-end, such as the Intel compiler) +// Comeau (this is a C++ to C generator) +// +// It may be useful to list the compilers/platforms the current version of +// type_traits doesn't support: +// Borland C++ (it simply has too many bugs with respect to templates). +// GCC 2.96 With a little effort, type_traits can probably be made to work with this compiler. +////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Implementation +// +// The implementation here is almost entirely based on template metaprogramming. +// This is whereby you use the compiler's template functionality to define types +// and values and make compilation decisions based on template declarations. +// Many of the algorithms here are similar to those found in books such as +// "Modern C++ Design" and C++ libraries such as Boost. The implementations here +// are simpler and more straightforward than those found in some libraries, due +// largely to our assumption that the compiler is good at donig template programming. +/////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_TYPE_TRAITS_H +#define EASTL_TYPE_TRAITS_H + + + +#include +#include // Is needed for size_t usage by some traits. + + + +namespace eastl +{ + + /////////////////////////////////////////////////////////////////////// + // integral_constant + // + // This is the base class for various type traits, as defined by the proposed + // C++ standard. This is essentially a utility base class for defining properties + // as both class constants (value) and as types (type). + // + template + struct integral_constant + { + static const T value = v; + typedef T value_type; + typedef integral_constant type; + }; + + + /////////////////////////////////////////////////////////////////////// + // true_type / false_type + // + // These are commonly used types in the implementation of type_traits. + // Other integral constant types can be defined, such as those based on int. + // + typedef integral_constant true_type; + typedef integral_constant false_type; + + + + /////////////////////////////////////////////////////////////////////// + // yes_type / no_type + // + // These are used as a utility to differentiate between two things. + // + typedef char yes_type; // sizeof(yes_type) == 1 + struct no_type { char padding[8]; }; // sizeof(no_type) != 1 + + + + /////////////////////////////////////////////////////////////////////// + // type_select + // + // This is used to declare a type from one of two type options. + // The result is based on the condition type. This has certain uses + // in template metaprogramming. + // + // Example usage: + // typedef ChosenType = type_select::value, ChoiceAType, ChoiceBType>::type; + // + template + struct type_select { typedef ConditionIsTrueType type; }; + + template + struct type_select { typedef ConditionIsFalseType type; }; + + + + /////////////////////////////////////////////////////////////////////// + // type_or + // + // This is a utility class for creating composite type traits. + // + template + struct type_or; + + template + struct type_or { static const bool value = true; }; + + template <> + struct type_or { static const bool value = false; }; + + + + /////////////////////////////////////////////////////////////////////// + // type_and + // + // This is a utility class for creating composite type traits. + // + template + struct type_and; + + template + struct type_and{ static const bool value = false; }; + + template <> + struct type_and{ static const bool value = true; }; + + + + /////////////////////////////////////////////////////////////////////// + // type_equal + // + // This is a utility class for creating composite type traits. + // + template + struct type_equal{ static const bool value = (b1 == b2); }; + + + + /////////////////////////////////////////////////////////////////////// + // type_not_equal + // + // This is a utility class for creating composite type traits. + // + template + struct type_not_equal{ static const bool value = (b1 != b2); }; + + + + /////////////////////////////////////////////////////////////////////// + // type_not + // + // This is a utility class for creating composite type traits. + // + template + struct type_not{ static const bool value = true; }; + + template <> + struct type_not{ static const bool value = false; }; + + + + /////////////////////////////////////////////////////////////////////// + // empty + // + template + struct empty{ }; + + +} // namespace eastl + + +// The following files implement the type traits themselves. +#if defined(__GNUC__) && (__GNUC__ <= 2) + #include + #include + #include + #include + #include +#else + #include + #include + #include + #include + #include +#endif + + +#endif // Header include guard + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/utility.h b/lib/eastl/include/EASTL/utility.h new file mode 100644 index 0000000..e2937c1 --- /dev/null +++ b/lib/eastl/include/EASTL/utility.h @@ -0,0 +1,312 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/utility.h +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + + +#ifndef EASTL_UTILITY_H +#define EASTL_UTILITY_H + + +#include + + +#ifdef _MSC_VER + #pragma warning(push) // VC++ generates a bogus warning that you cannot code away. + #pragma warning(disable: 4619) // There is no warning number 'number'. + #pragma warning(disable: 4217) // Member template functions cannot be used for copy-assignment or copy-construction. + #pragma warning(disable: 4512) // 'class' : assignment operator could not be generated. // This disabling would best be put elsewhere. +#endif + + +namespace eastl +{ + + /////////////////////////////////////////////////////////////////////// + /// rel_ops + /// + /// rel_ops allow the automatic generation of operators !=, >, <=, >= from + /// just operators == and <. These are intentionally in the rel_ops namespace + /// so that they don't conflict with other similar operators. To use these + /// operators, add "using namespace std::rel_ops;" to an appropriate place in + /// your code, usually right in the function that you need them to work. + /// In fact, you will very likely have collision problems if you put such + /// using statements anywhere other than in the .cpp file like so and may + /// also have collisions when you do, as the using statement will affect all + /// code in the module. You need to be careful about use of rel_ops. + /// + namespace rel_ops + { + template + inline bool operator!=(const T& x, const T& y) + { return !(x == y); } + + template + inline bool operator>(const T& x, const T& y) + { return (y < x); } + + template + inline bool operator<=(const T& x, const T& y) + { return !(y < x); } + + template + inline bool operator>=(const T& x, const T& y) + { return !(x < y); } + } + + + + /////////////////////////////////////////////////////////////////////// + /// pair + /// + /// Implements a simple pair, just like the C++ std::pair. + /// + template + struct pair + { + typedef T1 first_type; + typedef T2 second_type; + + T1 first; + T2 second; + + pair(); + pair(const T1& x); + pair(const T1& x, const T2& y); + + template + pair(const pair& p); + + // pair(const pair& p); // Not necessary, as default version is OK. + // pair& operator=(const pair& p); // Not necessary, as default version is OK. + }; + + + + + /// use_self + /// + /// operator()(x) simply returns x. Used in sets, as opposed to maps. + /// This is a template policy implementation; it is an alternative to + /// the use_first template implementation. + /// + /// The existance of use_self may seem odd, given that it does nothing, + /// but these kinds of things are useful, virtually required, for optimal + /// generic programming. + /// + template + struct use_self // : public unary_function // Perhaps we want to make it a subclass of unary_function. + { + typedef T result_type; + + const T& operator()(const T& x) const + { return x; } + }; + + /// use_first + /// + /// operator()(x) simply returns x.first. Used in maps, as opposed to sets. + /// This is a template policy implementation; it is an alternative to + /// the use_self template implementation. This is the same thing as the + /// SGI SGL select1st utility. + /// + template + struct use_first // : public unary_function // Perhaps we want to make it a subclass of unary_function. + { + typedef typename Pair::first_type result_type; + + const result_type& operator()(const Pair& x) const + { return x.first; } + }; + + /// use_second + /// + /// operator()(x) simply returns x.second. + /// This is the same thing as the SGI SGL select2nd utility + /// + template + struct use_second // : public unary_function // Perhaps we want to make it a subclass of unary_function. + { + typedef typename Pair::second_type result_type; + + const result_type& operator()(const Pair& x) const + { return x.second; } + }; + + + + + + /////////////////////////////////////////////////////////////////////// + // pair + /////////////////////////////////////////////////////////////////////// + + template + inline pair::pair() + : first(), second() + { + // Empty + } + + + template + inline pair::pair(const T1& x) + : first(x), second() + { + // Empty + } + + + template + inline pair::pair(const T1& x, const T2& y) + : first(x), second(y) + { + // Empty + } + + + template + template + inline pair::pair(const pair& p) + : first(p.first), second(p.second) + { + // Empty + } + + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const pair& a, const pair& b) + { + return ((a.first == b.first) && (a.second == b.second)); + } + + + template + inline bool operator<(const pair& a, const pair& b) + { + // Note that we use only operator < in this expression. Otherwise we could + // use the simpler: return (a.m1 == b.m1) ? (a.m2 < b.m2) : (a.m1 < b.m1); + // The user can write a specialization for this operator to get around this + // in cases where the highest performance is required. + return ((a.first < b.first) || (!(b.first < a.first) && (a.second < b.second))); + } + + + template + inline bool operator!=(const pair& a, const pair& b) + { + return !(a == b); + } + + + template + inline bool operator>(const pair& a, const pair& b) + { + return b < a; + } + + + template + inline bool operator>=(const pair& a, const pair& b) + { + return !(a < b); + } + + + template + inline bool operator<=(const pair& a, const pair& b) + { + return !(b < a); + } + + + + + /////////////////////////////////////////////////////////////////////// + /// make_pair / make_pair_ref + /// + /// make_pair is the same as std::make_pair specified by the C++ standard. + /// If you look at the C++ standard, you'll see that it specifies T& instead of T. + /// However, it has been determined that the C++ standard is incorrect and has + /// flagged it as a defect (http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181). + /// In case you feel that you want a more efficient version that uses references, + /// we provide the make_pair_ref function below. + /// + /// Note: You don't need to use make_pair in order to make a pair. The following + /// code is equivalent, and the latter avoids one more level of inlining: + /// return make_pair(charPtr, charPtr); + /// return pair(charPtr, charPtr); + /// + template + inline pair make_pair(T1 a, T2 b) + { + return pair(a, b); + } + + + template + inline pair make_pair_ref(const T1& a, const T2& b) + { + return pair(a, b); + } + + +} // namespace eastl + + +#ifdef _MSC_VER + #pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/vector.h b/lib/eastl/include/EASTL/vector.h new file mode 100644 index 0000000..101b6c2 --- /dev/null +++ b/lib/eastl/include/EASTL/vector.h @@ -0,0 +1,1618 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/vector.h +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// This file implements a vector (array-like container), much like the C++ +// std::vector class. +// The primary distinctions between this vector and std::vector are: +// - vector has a couple extension functions that increase performance. +// - vector can contain objects with alignment requirements. std::vector +// cannot do so without a bit of tedious non-portable effort. +// - vector supports debug memory naming natively. +// - vector is easier to read, debug, and visualize. +// - vector is savvy to an environment that doesn't have exception handling, +// as is sometimes the case with console or embedded environments. +// - vector has less deeply nested function calls and allows the user to +// enable forced inlining in debug builds in order to reduce bloat. +// - vector is a vector of boolean values and not a bit vector. +// - vector guarantees that memory is contiguous and that vector::iterator +// is nothing more than a pointer to T. +// - vector has an explicit data() method for obtaining a pointer to storage +// which is safe to call even if the block is empty. This avoids the +// common &v[0], &v.front(), and &*v.begin() constructs that trigger false +// asserts in STL debugging modes. +// - vector::size_type is defined as eastl_size_t instead of size_t in order to +// save memory and run faster on 64 bit systems. +// - vector data is guaranteed to be contiguous. +// - vector has a set_capacity() function which frees excess capacity. +// The only way to do this with std::vector is via the cryptic non-obvious +// trick of using: vector(x).swap(x); +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_VECTOR_H +#define EASTL_VECTOR_H + + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +# pragma warning(push, 0) +# include +# include +# pragma warning(pop) +#else +# include +# include +#endif + +#if EASTL_EXCEPTIONS_ENABLED +# ifdef _MSC_VER +# pragma warning(push, 0) +# endif +# include // std::out_of_range, std::length_error. +# ifdef _MSC_VER +# pragma warning(pop) +# endif +#endif + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc +# pragma warning(disable: 4345) // Behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized +# pragma warning(disable: 4244) // Argument: conversion from 'int' to 'const eastl::vector::value_type', possible loss of data +# pragma warning(disable: 4127) // Conditional expression is constant +# pragma warning(disable: 4480) // nonstandard extension used: specifying underlying type for enum +#endif + + +namespace eastl +{ + + /// EASTL_VECTOR_DEFAULT_NAME + /// + /// Defines a default container name in the absence of a user-provided name. + /// +#ifndef EASTL_VECTOR_DEFAULT_NAME +# define EASTL_VECTOR_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " vector" // Unless the user overrides something, this is "EASTL vector". +#endif + + + /// EASTL_VECTOR_DEFAULT_ALLOCATOR + /// +#ifndef EASTL_VECTOR_DEFAULT_ALLOCATOR +# define EASTL_VECTOR_DEFAULT_ALLOCATOR allocator_type(EASTL_VECTOR_DEFAULT_NAME) +#endif + + + + /// VectorBase + /// + /// The reason we have a VectorBase class is that it makes exception handling + /// simpler to implement because memory allocation is implemented entirely + /// in this class. If a user creates a vector which needs to allocate + /// memory in the constructor, VectorBase handles it. If an exception is thrown + /// by the allocator then the exception throw jumps back to the user code and + /// no try/catch code need be written in the vector or VectorBase constructor. + /// If an exception is thrown in the vector (not VectorBase) constructor, the + /// destructor for VectorBase will be called automatically (and free the allocated + /// memory) before the execution jumps back to the user code. + /// However, if the vector class were to handle both allocation and initialization + /// then it would have no choice but to implement an explicit try/catch statement + /// for all pathways that allocate memory. This increases code size and decreases + /// performance and makes the code a little harder read and maintain. + /// + /// The C++ standard (15.2 paragraph 2) states: + /// "An object that is partially constructed or partially destroyed will + /// have destructors executed for all its fully constructed subobjects, + /// that is, for subobjects for which the constructor has been completed + /// execution and the destructor has not yet begun execution." + /// + /// The C++ standard (15.3 paragraph 11) states: + /// "The fully constructed base classes and members of an object shall + /// be destroyed before entering the handler of a function-try-block + /// of a constructor or destructor for that block." + /// + template + struct VectorBase + { + typedef Allocator allocator_type; + typedef eastl_size_t size_type; // See config.h for the definition of eastl_size_t, which defaults to uint32_t. + typedef ptrdiff_t difference_type; + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) // _MSC_VER of 1400 means VC8 (VS2005), 1500 means VC9 (VS2008) + enum : size_type { // Use Microsoft enum language extension, allowing for smaller debug symbols than using a static const. Users have been affected by this. + npos = (size_type)-1, + kMaxSize = (size_type)-2 + }; +#else + static const size_type npos = (size_type)-1; /// 'npos' means non-valid position or simply non-position. + static const size_type kMaxSize = (size_type)-2; /// -1 is reserved for 'npos'. It also happens to be slightly beneficial that kMaxSize is a value less than -1, as it helps us deal with potential integer wraparound issues. +#endif + + enum + { + kAlignment = EASTL_ALIGN_OF(T), + kAlignmentOffset = 0 + }; + + protected: + T* mpBegin; + T* mpEnd; + T* mpCapacity; + allocator_type mAllocator; // To do: Use base class optimization to make this go away. + + public: + VectorBase(); + VectorBase(const allocator_type& allocator); + VectorBase(size_type n, const allocator_type& allocator); + + ~VectorBase(); + + allocator_type& get_allocator(); + void set_allocator(const allocator_type& allocator); + + protected: + T* DoAllocate(size_type n); + void DoFree(T* p, size_type n); + size_type GetNewCapacity(size_type currentCapacity); + + }; // VectorBase + + + + + /// vector + /// + /// Implements a dynamic array. + /// + template + class vector : public VectorBase + { + typedef VectorBase base_type; + typedef vector this_type; + + public: + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; // Maintainer note: We want to leave iterator defined as T* -- at least in release builds -- as this gives some algorithms an advantage that optimizers cannot get around. + typedef T* iterator; // Note: iterator is simply T* right now, but this will likely change in the future, at least for debug builds. + typedef const T* const_iterator; // Do not write code that relies on iterator being T*. The reason it will + typedef eastl::reverse_iterator reverse_iterator; // change in the future is that a debugging iterator system will be created. + typedef eastl::reverse_iterator const_reverse_iterator; + typedef typename base_type::size_type size_type; + typedef typename base_type::difference_type difference_type; + typedef typename base_type::allocator_type allocator_type; + + using base_type::mpBegin; + using base_type::mpEnd; + using base_type::mpCapacity; + using base_type::mAllocator; + using base_type::npos; + using base_type::GetNewCapacity; + using base_type::DoAllocate; + using base_type::DoFree; + + public: + vector(); + explicit vector(const allocator_type& allocator); + explicit vector(size_type n, const allocator_type& allocator = EASTL_VECTOR_DEFAULT_ALLOCATOR); + vector(size_type n, const value_type& value, const allocator_type& allocator = EASTL_VECTOR_DEFAULT_ALLOCATOR); + vector(const this_type& x); + +#ifdef EA_COMPILER_HAS_MOVE_SEMANTICS + vector(this_type&& x); + this_type& operator =(this_type&& x); + iterator insert(iterator position, value_type&& value); + void push_back(value_type&& x); +# ifdef EA_COMPILER_HAS_VARIADIC_TEMPLATES + /* + template + iterator emplace(const_iterator pos, Args&& ... args); + template + iterator emplace_back(const_iterator pos, Args&& ... args); + */ +# endif +#endif + + template + vector(InputIterator first, InputIterator last); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg. + + ~vector(); + + this_type& operator=(const this_type& x); + void swap(this_type& x); + + void assign(size_type n, const value_type& value); + + template + void assign(InputIterator first, InputIterator last); + + iterator begin(); + const_iterator begin() const; + + iterator end(); + const_iterator end() const; + + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; + + reverse_iterator rend(); + const_reverse_iterator rend() const; + + bool empty() const; + size_type size() const; + size_type capacity() const; + + void resize(size_type n, const value_type& value); + void resize(size_type n); + void reserve(size_type n); + void set_capacity(size_type n = base_type::npos); // Revises the capacity to the user-specified value. Resizes the container to match the capacity if the requested capacity n is less than the current size. If n == npos then the capacity is reallocated (if necessary) such that capacity == size. + + pointer data(); + const_pointer data() const; + + reference operator[](size_type n); + const_reference operator[](size_type n) const; + + reference at(size_type n); + const_reference at(size_type n) const; + + reference front(); + const_reference front() const; + + reference back(); + const_reference back() const; + + void push_back(const value_type& value); + reference push_back(); + void* push_back_uninitialized(); + + void pop_back(); + + iterator insert(iterator position, const value_type& value); + void insert(iterator position, size_type n, const value_type& value); + + template + void insert(iterator position, InputIterator first, InputIterator last); + + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + reverse_iterator erase(reverse_iterator position); + reverse_iterator erase(reverse_iterator first, reverse_iterator last); + + void clear(); + void reset(); /// This is a unilateral reset to an initially empty state. No destructors are called, no deallocation occurs. + + bool validate() const; + int validate_iterator(const_iterator i) const; + + protected: + // These functions do the real work of maintaining the vector. You will notice + // that many of them have the same name but are specialized on iterator_tag + // (iterator categories). This is because in these cases there is an optimized + // implementation that can be had for some cases relative to others. Functions + // which aren't referenced are neither compiled nor linked into the application. + + template + pointer DoRealloc(size_type n, ForwardIterator first, ForwardIterator last); + + template + void DoInit(Integer n, Integer value, true_type); + + template + void DoInit(InputIterator first, InputIterator last, false_type); + + template + void DoInitFromIterator(InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag); + + template + void DoInitFromIterator(ForwardIterator first, ForwardIterator last, EASTL_ITC_NS::forward_iterator_tag); + + void DoDestroyValues(pointer first, pointer last); + + template + void DoAssign(Integer n, Integer value, true_type); + + template + void DoAssign(InputIterator first, InputIterator last, false_type); + + void DoAssignValues(size_type n, const value_type& value); + + template + void DoAssignFromIterator(InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag); + + template + void DoAssignFromIterator(RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag); + + template + void DoInsert(iterator position, Integer n, Integer value, true_type); + + template + void DoInsert(iterator position, InputIterator first, InputIterator last, false_type); + + template + void DoInsertFromIterator(iterator position, InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag); + + template + void DoInsertFromIterator(iterator position, BidirectionalIterator first, BidirectionalIterator last, EASTL_ITC_NS::bidirectional_iterator_tag); + + void DoInsertValues(iterator position, size_type n, const value_type& value); + + void DoInsertValue(iterator position, const value_type& value); + + }; // class vector + + + + + + + /////////////////////////////////////////////////////////////////////// + // VectorBase + /////////////////////////////////////////////////////////////////////// + + template + inline VectorBase::VectorBase() + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(EASTL_VECTOR_DEFAULT_NAME) + { + } + + template + inline VectorBase::VectorBase(const allocator_type& allocator) + : mpBegin(NULL), + mpEnd(NULL), + mpCapacity(NULL), + mAllocator(allocator) + { + } + + + template + inline VectorBase::VectorBase(size_type n, const allocator_type& allocator) + : mAllocator(allocator) + { + mpBegin = DoAllocate(n); + mpEnd = mpBegin; + mpCapacity = mpBegin + n; + } + + + template + inline VectorBase::~VectorBase() + { + if(mpBegin) + EASTLFree(mAllocator, mpBegin, (mpCapacity - mpBegin) * sizeof(T)); + } + + + template + inline typename VectorBase::allocator_type& + VectorBase::get_allocator() + { + return mAllocator; + } + + + template + inline void VectorBase::set_allocator(const allocator_type& allocator) + { + mAllocator = allocator; + } + + + template + inline T* VectorBase::DoAllocate(size_type n) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= 0x80000000)) + EASTL_FAIL_MSG("vector::DoAllocate -- improbably large request."); +#endif + + // If n is zero, then we allocate no memory and just return NULL. + // This is fine, as our default ctor initializes with NULL pointers. + return n ? (T*)allocate_memory(mAllocator, n * sizeof(T), kAlignment, kAlignmentOffset) : NULL; + } + + + template + inline void VectorBase::DoFree(T* p, size_type n) + { + if(p) + EASTLFree(mAllocator, p, n * sizeof(T)); + } + + + template + inline typename VectorBase::size_type + VectorBase::GetNewCapacity(size_type currentCapacity) + { + // This needs to return a value of at least currentCapacity and at least 1. + return (currentCapacity > 0) ? (2 * currentCapacity) : 1; + } + + + + + /////////////////////////////////////////////////////////////////////// + // vector + /////////////////////////////////////////////////////////////////////// + + template + inline vector::vector() + : base_type() + { + // Empty + } + + + template + inline vector::vector(const allocator_type& allocator) + : base_type(allocator) + { + // Empty + } + + + template + inline vector::vector(size_type n, const allocator_type& allocator) + : base_type(n, allocator) + { + eastl::uninitialized_fill_n_ptr(mpBegin, n, value_type()); + mpEnd = mpBegin + n; + } + + + template + inline vector::vector(size_type n, const value_type& value, const allocator_type& allocator) + : base_type(n, allocator) + { + eastl::uninitialized_fill_n_ptr(mpBegin, n, value); + mpEnd = mpBegin + n; + } + + + template + inline vector::vector(const this_type& x) + : base_type(x.size(), x.mAllocator) + { + mpEnd = eastl::uninitialized_copy_ptr(x.mpBegin, x.mpEnd, mpBegin); + } + + + template + template + inline vector::vector(InputIterator first, InputIterator last) + : base_type(EASTL_VECTOR_DEFAULT_ALLOCATOR) + { + DoInit(first, last, is_integral()); + } + +#ifdef EA_COMPILER_HAS_MOVE_SEMANTICS + template + inline vector::vector(vector&& x) + : base_type() + { + if(&x == this) { return; } + + swap(x); + } + + template + inline vector& vector::operator =(vector&& x) + { + if(&x != this) { + this->~VectorBase(); + + mpBegin = NULL; + mpEnd = NULL; + mpCapacity = NULL; + mAllocator = EASTL_VECTOR_DEFAULT_NAME; + + swap(x); + } + return *this; + } + + template + inline typename vector::iterator vector::insert( + typename vector::iterator const pos, T&& x) + { + iterator const ret = insert(pos, value_type()); + *ret = x; + return ret; + } + + template + inline void vector::push_back(T&& x) { + push_back() = x; + } +# ifdef EA_COMPILER_HAS_VARIADIC_TEMPLATES + /* + template + template + typename vector::iterator vector::emplace(const_iterator pos, Args&& ... args); + + template + template + typename vector::iterator vector::emplace_back(const_iterator pos, Args&& ... args); + */ +# endif +#endif + + template + inline vector::~vector() + { + // Call destructor for the values. Parent class will free the memory. + DoDestroyValues(mpBegin, mpEnd); + } + + + template + typename vector::this_type& + vector::operator=(const this_type& x) + { + if(&x != this) + { +#if EASTL_ALLOCATOR_COPY_ENABLED + mAllocator = x.mAllocator; +#endif + + const size_type n = x.size(); + + if(n > size_type(mpCapacity - mpBegin)) // If n > capacity ... + { + pointer const pNewData = DoRealloc(n, x.mpBegin, x.mpEnd); + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + mpBegin = pNewData; + mpCapacity = mpBegin + n; + } + else if(n > size_type(mpEnd - mpBegin)) // If size < n <= capacity ... + { + eastl::copy(x.mpBegin, x.mpBegin + (mpEnd - mpBegin), mpBegin); + eastl::uninitialized_copy_ptr(x.mpBegin + (mpEnd - mpBegin), x.mpEnd, mpEnd); + } + else // else n <= size + { + iterator const position = eastl::copy(x.mpBegin, x.mpEnd, mpBegin); + DoDestroyValues(position, mpEnd); + } + mpEnd = mpBegin + n; + } + return *this; + } + + + template + inline void vector::assign(size_type n, const value_type& value) + { + DoAssignValues(n, value); + } + + + template + template + inline void vector::assign(InputIterator first, InputIterator last) + { + // It turns out that the C++ std::vector specifies a two argument + // version of assign that takes (int size, int value). These are not iterators, + // so we need to do a template compiler trick to do the right thing. + DoAssign(first, last, is_integral()); + } + + + template + inline typename vector::iterator + vector::begin() + { + return mpBegin; + } + + + template + inline typename vector::const_iterator + vector::begin() const + { + return mpBegin; + } + + + template + inline typename vector::iterator + vector::end() + { + return mpEnd; + } + + + template + inline typename vector::const_iterator + vector::end() const + { + return mpEnd; + } + + + template + inline typename vector::reverse_iterator + vector::rbegin() + { + return reverse_iterator(mpEnd); + } + + + template + inline typename vector::const_reverse_iterator + vector::rbegin() const + { + return const_reverse_iterator(mpEnd); + } + + + template + inline typename vector::reverse_iterator + vector::rend() + { + return reverse_iterator(mpBegin); + } + + + template + inline typename vector::const_reverse_iterator + vector::rend() const + { + return const_reverse_iterator(mpBegin); + } + + + template + bool vector::empty() const + { + return (mpBegin == mpEnd); + } + + + template + inline typename vector::size_type + vector::size() const + { + return (size_type)(mpEnd - mpBegin); + } + + + template + inline typename vector::size_type + vector::capacity() const + { + return (size_type)(mpCapacity - mpBegin); + } + + + template + inline void vector::resize(size_type n, const value_type& value) + { + if(n > (size_type)(mpEnd - mpBegin)) // We expect that more often than not, resizes will be upsizes. + insert(mpEnd, n - ((size_type)(mpEnd - mpBegin)), value); + else + erase(mpBegin + n, mpEnd); + } + + + template + inline void vector::resize(size_type n) + { + // Alternative implementation: + // resize(n, value_type()); + + if(n > (size_type)(mpEnd - mpBegin)) // We expect that more often than not, resizes will be upsizes. + insert(mpEnd, n - ((size_type)(mpEnd - mpBegin)), value_type()); + else + erase(mpBegin + n, mpEnd); + } + + + template + void vector::reserve(size_type n) + { + // If the user wants to reduce the reserved memory, there is the set_capacity function. + if(n > size_type(mpCapacity - mpBegin)) // If n > capacity ... + { + // To consider: fold this reserve implementation with the set_capacity + // implementation below. But we need to be careful to not call resize + // in the implementation, as that would require the user to have a + // default constructor, which we are trying to avoid. + pointer const pNewData = DoRealloc(n, mpBegin, mpEnd); + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + const ptrdiff_t nPrevSize = mpEnd - mpBegin; + mpBegin = pNewData; + mpEnd = pNewData + nPrevSize; + mpCapacity = mpBegin + n; + } + } + + + template + void vector::set_capacity(size_type n) + { + if((n == npos) || (n <= (size_type)(mpEnd - mpBegin))) // If new capacity <= size... + { + if(n < (size_type)(mpEnd - mpBegin)) + resize(n); + + this_type temp(*this); // This is the simplest way to accomplish this, + swap(temp); // and it is as efficient as any other. + } + else // Else new capacity > size. + { + pointer const pNewData = DoRealloc(n, mpBegin, mpEnd); + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + const ptrdiff_t nPrevSize = mpEnd - mpBegin; + mpBegin = pNewData; + mpEnd = pNewData + nPrevSize; + mpCapacity = mpBegin + n; + } + } + + + template + inline typename vector::pointer + vector::data() + { + return mpBegin; + } + + + template + inline typename vector::const_pointer + vector::data() const + { + return mpBegin; + } + + + template + inline typename vector::reference + vector::operator[](size_type n) + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED // We allow the user to use a reference to v[0] of an empty container. + if(EASTL_UNLIKELY((n != 0) && (n >= (static_cast(mpEnd - mpBegin))))) + EASTL_FAIL_MSG("vector::operator[] -- out of range"); +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("vector::operator[] -- out of range"); +#endif + + return *(mpBegin + n); + } + + + template + inline typename vector::const_reference + vector::operator[](size_type n) const + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED // We allow the user to use a reference to v[0] of an empty container. + if(EASTL_UNLIKELY((n != 0) && (n >= (static_cast(mpEnd - mpBegin))))) + EASTL_FAIL_MSG("vector::operator[] -- out of range"); +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("vector::operator[] -- out of range"); +#endif + + return *(mpBegin + n); + } + + + template + inline typename vector::reference + vector::at(size_type n) + { +#if EASTL_EXCEPTIONS_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + throw std::out_of_range("vector::at -- out of range"); +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("vector::at -- out of range"); +#endif + + return *(mpBegin + n); + } + + + template + inline typename vector::const_reference + vector::at(size_type n) const + { +#if EASTL_EXCEPTIONS_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + throw std::out_of_range("vector::at -- out of range"); +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(n >= (static_cast(mpEnd - mpBegin)))) + EASTL_FAIL_MSG("vector::at -- out of range"); +#endif + + return *(mpBegin + n); + } + + + template + inline typename vector::reference + vector::front() + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We don't allow the user to reference an empty container. + EASTL_FAIL_MSG("vector::front -- empty vector"); +#endif + + return *mpBegin; + } + + + template + inline typename vector::const_reference + vector::front() const + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We don't allow the user to reference an empty container. + EASTL_FAIL_MSG("vector::front -- empty vector"); +#endif + + return *mpBegin; + } + + + template + inline typename vector::reference + vector::back() + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We don't allow the user to reference an empty container. + EASTL_FAIL_MSG("vector::back -- empty vector"); +#endif + + return *(mpEnd - 1); + } + + + template + inline typename vector::const_reference + vector::back() const + { +#if EASTL_EMPTY_REFERENCE_ASSERT_ENABLED + // We allow the user to reference an empty container. +#elif EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) // We don't allow the user to reference an empty container. + EASTL_FAIL_MSG("vector::back -- empty vector"); +#endif + + return *(mpEnd - 1); + } + + + template + inline void vector::push_back(const value_type& value) + { + if(mpEnd < mpCapacity) + ::new(mpEnd++) value_type(value); + else + DoInsertValue(mpEnd, value); + } + + + template + inline typename vector::reference + vector::push_back() + { + if(mpEnd < mpCapacity) + ::new(mpEnd++) value_type(); + else // Note that in this case we create a temporary, which is less desirable. + DoInsertValue(mpEnd, value_type()); + + return *(mpEnd - 1); // Same as return back(); + } + + + template + inline void* vector::push_back_uninitialized() + { + if(mpEnd == mpCapacity) + { + const size_type newSize = (size_type)(mpEnd - mpBegin) + 1; + reserve(newSize); + } + + return mpEnd++; + } + + + template + inline void vector::pop_back() + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY(mpEnd <= mpBegin)) + EASTL_FAIL_MSG("vector::pop_back -- empty vector"); +#endif + + --mpEnd; + mpEnd->~value_type(); + } + + + template + inline typename vector::iterator + vector::insert(iterator position, const value_type& value) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((position < mpBegin) || (position > mpEnd))) + EASTL_FAIL_MSG("vector::insert -- invalid position"); +#endif + + const ptrdiff_t n = position - mpBegin; // Save this because we might reallocate. + + if((mpEnd == mpCapacity) || (position != mpEnd)) + DoInsertValue(position, value); + else + ::new(mpEnd++) value_type(value); + + return mpBegin + n; + } + + + template + inline void vector::insert(iterator position, size_type n, const value_type& value) + { + DoInsertValues(position, n, value); + } + + + template + template + inline void vector::insert(iterator position, InputIterator first, InputIterator last) + { + DoInsert(position, first, last, is_integral()); + } + + + template + inline typename vector::iterator + vector::erase(iterator position) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((position < mpBegin) || (position >= mpEnd))) + EASTL_FAIL_MSG("vector::erase -- invalid position"); +#endif + + if((position + 1) < mpEnd) + eastl::copy(position + 1, mpEnd, position); + --mpEnd; + mpEnd->~value_type(); + return position; + } + + + template + inline typename vector::iterator + vector::erase(iterator first, iterator last) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((first < mpBegin) || (first > mpEnd) || (last < mpBegin) || (last > mpEnd) || (last < first))) + EASTL_FAIL_MSG("vector::erase -- invalid position"); +#endif + + //#if 0 + // Reference implementation, known to be correct: + iterator const position = eastl::copy(last, mpEnd, first); + DoDestroyValues(position, mpEnd); + mpEnd -= (last - first); + //#else + // To do: Test this. + // // Implementation that has an optimization for memcpy which eastl::copy cannot do (the best it can do is memmove). + // iterator position; + // T* const pEnd = mpEnd - (last - first); + // + // if((pEnd <= last) && eastl::has_trivial_assign::value) // If doing a non-overlapping copy and the data is memcpy-able + // { + // const size_t size = (size_t)((uintptr_t)mpEnd-(uintptr_t)last); + // position = (T*)((uintptr_t)memcpy(first, last, size) + size); + // } + // else + // position = eastl::copy(last, mpEnd, first); + // + // DoDestroyValues(position, mpEnd); + // mpEnd = pEnd; + //#endif + + return first; + } + + + template + inline typename vector::reverse_iterator + vector::erase(reverse_iterator position) + { + return reverse_iterator(erase((++position).base())); + } + + + template + inline typename vector::reverse_iterator + vector::erase(reverse_iterator first, reverse_iterator last) + { + // Version which erases in order from first to last. + // difference_type i(first.base() - last.base()); + // while(i--) + // first = erase(first); + // return first; + + // Version which erases in order from last to first, but is slightly more efficient: + return reverse_iterator(erase((++last).base(), (++first).base())); + } + + + template + inline void vector::clear() + { + DoDestroyValues(mpBegin, mpEnd); + mpEnd = mpBegin; + } + + + template + inline void vector::reset() + { + // The reset function is a special extension function which unilaterally + // resets the container to an empty state without freeing the memory of + // the contained objects. This is useful for very quickly tearing down a + // container built into scratch memory. + mpBegin = mpEnd = mpCapacity = NULL; + } + + + template + inline void vector::swap(this_type& x) + { + if(mAllocator == x.mAllocator) // If allocators are equivalent... + { + // We leave mAllocator as-is. + eastl::swap(mpBegin, x.mpBegin); + eastl::swap(mpEnd, x.mpEnd); + eastl::swap(mpCapacity, x.mpCapacity); + } + else // else swap the contents. + { + const this_type temp(*this); // Can't call eastl::swap because that would + *this = x; // itself call this member swap function. + x = temp; + } + } + + + template + template + inline typename vector::pointer + vector::DoRealloc(size_type n, ForwardIterator first, ForwardIterator last) + { + T* const p = DoAllocate(n); + eastl::uninitialized_copy_ptr(first, last, p); + return p; + } + + + template + template + inline void vector::DoInit(Integer n, Integer value, true_type) + { + mpBegin = DoAllocate((size_type)n); + mpCapacity = mpBegin + n; + mpEnd = mpCapacity; + eastl::uninitialized_fill_n_ptr(mpBegin, n, value); + } + + + template + template + inline void vector::DoInit(InputIterator first, InputIterator last, false_type) + { + typedef typename eastl::iterator_traits:: iterator_category IC; + DoInitFromIterator(first, last, IC()); + } + + + template + template + inline void vector::DoInitFromIterator(InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag) + { + for(; first < last; ++first) // InputIterators by definition actually only allow you to iterate through them once. + push_back(*first); // Thus the standard *requires* that we do this (inefficient) implementation. + } // Luckily, InputIterators are in practice almost never used, so this code will likely never get executed. + + + template + template + inline void vector::DoInitFromIterator(ForwardIterator first, ForwardIterator last, EASTL_ITC_NS::forward_iterator_tag) + { + const size_type n = (size_type)eastl::distance(first, last); + mpBegin = DoAllocate(n); + mpCapacity = mpBegin + n; + mpEnd = mpCapacity; + eastl::uninitialized_copy_ptr(first, last, mpBegin); + } + + + template + inline void vector::DoDestroyValues(pointer first, pointer last) + { + for(; first < last; ++first) // In theory, this could be an external function that works on an iterator. + first->~value_type(); + } + + + template + template + inline void vector::DoAssign(Integer n, Integer value, true_type) + { + DoAssignValues(static_cast(n), static_cast(value)); + } + + + template + template + inline void vector::DoAssign(InputIterator first, InputIterator last, false_type) + { + typedef typename eastl::iterator_traits::iterator_category IC; + DoAssignFromIterator(first, last, IC()); + } + + + template + void vector::DoAssignValues(size_type n, const value_type& value) + { + if(n > size_type(mpCapacity - mpBegin)) // If n > capacity ... + { + this_type temp(n, value, mAllocator); // We have little choice but to reallocate with new memory. + swap(temp); + } + else if(n > size_type(mpEnd - mpBegin)) // If n > size ... + { + eastl::fill(mpBegin, mpEnd, value); + eastl::uninitialized_fill_n_ptr(mpEnd, n - size_type(mpEnd - mpBegin), value); + mpEnd += n - size_type(mpEnd - mpBegin); + } + else // else 0 <= n <= size + { + eastl::fill_n(mpBegin, n, value); + erase(mpBegin + n, mpEnd); + } + } + + + template + template + void vector::DoAssignFromIterator(InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag) + { + iterator position(mpBegin); + + while((position != mpEnd) && (first != last)) + { + *position = *first; + ++first; + ++position; + } + if(first == last) + erase(position, mpEnd); + else + insert(mpEnd, first, last); + } + + + template + template + void vector::DoAssignFromIterator(RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag) + { + const size_type n = (size_type)eastl::distance(first, last); + + if(n > size_type(mpCapacity - mpBegin)) // If n > capacity ... + { + pointer const pNewData = DoRealloc(n, first, last); + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + mpBegin = pNewData; + mpEnd = mpBegin + n; + mpCapacity = mpEnd; + } + else if(n <= size_type(mpEnd - mpBegin)) // If n <= size ... + { + pointer const pNewEnd = eastl::copy(first, last, mpBegin); // Since we are copying to mpBegin, we don't have to worry about needing copy_backward or a memmove-like copy (as opposed to memcpy-like copy). + DoDestroyValues(pNewEnd, mpEnd); + mpEnd = pNewEnd; + } + else // else size < n <= capacity + { + RandomAccessIterator position = first + (mpEnd - mpBegin); + eastl::copy(first, position, mpBegin); // Since we are copying to mpBegin, we don't have to worry about needing copy_backward or a memmove-like copy (as opposed to memcpy-like copy). + mpEnd = eastl::uninitialized_copy_ptr(position, last, mpEnd); + } + } + + + template + template + inline void vector::DoInsert(iterator position, Integer n, Integer value, true_type) + { + DoInsertValues(position, static_cast(n), static_cast(value)); + } + + + template + template + inline void vector::DoInsert(iterator position, InputIterator first, InputIterator last, false_type) + { + typedef typename eastl::iterator_traits::iterator_category IC; + DoInsertFromIterator(position, first, last, IC()); + } + + + template + template + inline void vector::DoInsertFromIterator(iterator position, InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag) + { + for(; first != last; ++first, ++position) + position = insert(position, *first); + } + + + template + template + void vector::DoInsertFromIterator(iterator position, BidirectionalIterator first, BidirectionalIterator last, EASTL_ITC_NS::bidirectional_iterator_tag) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((position < mpBegin) || (position > mpEnd))) + EASTL_FAIL_MSG("vector::insert -- invalid position"); +#endif + + if(first != last) + { + const size_type n = (size_type)eastl::distance(first, last); + + if(n <= size_type(mpCapacity - mpEnd)) // If n fits within the existing capacity... + { + const size_type nExtra = static_cast(mpEnd - position); + const pointer pEnd = mpEnd; + + if(n < nExtra) + { + eastl::uninitialized_copy_ptr(mpEnd - n, mpEnd, mpEnd); + mpEnd += n; + eastl::copy_backward(position, pEnd - n, pEnd); // We need copy_backward because of potential overlap issues. + eastl::copy(first, last, position); + } + else + { + BidirectionalIterator fiTemp = first; + eastl::advance(fiTemp, nExtra); + eastl::uninitialized_copy_ptr(fiTemp, last, mpEnd); + mpEnd += n - nExtra; + eastl::uninitialized_copy_ptr(position, pEnd, mpEnd); + mpEnd += nExtra; + eastl::copy_backward(first, fiTemp, position + nExtra); + } + } + else // else we need to expand our capacity. + { + const size_type nPrevSize = size_type(mpEnd - mpBegin); + const size_type nGrowSize = GetNewCapacity(nPrevSize); + const size_type nNewSize = nGrowSize > (nPrevSize + n) ? nGrowSize : (nPrevSize + n); + pointer const pNewData = DoAllocate(nNewSize); + +#if EASTL_EXCEPTIONS_ENABLED + pointer pNewEnd = pNewData; + try + { + pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + pNewEnd = eastl::uninitialized_copy_ptr(first, last, pNewEnd); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, pNewEnd); + } + catch(...) + { + DoDestroyValues(pNewData, pNewEnd); + DoFree(pNewData, nNewSize); + throw; + } +#else + pointer pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + pNewEnd = eastl::uninitialized_copy_ptr(first, last, pNewEnd); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, pNewEnd); +#endif + + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + mpBegin = pNewData; + mpEnd = pNewEnd; + mpCapacity = pNewData + nNewSize; + } + } + } + + + template + void vector::DoInsertValues(iterator position, size_type n, const value_type& value) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((position < mpBegin) || (position > mpEnd))) + EASTL_FAIL_MSG("vector::insert -- invalid position"); +#endif + + if(n <= size_type(mpCapacity - mpEnd)) // If n is <= capacity... + { + if(n > 0) // To do: See if there is a way we can eliminate this 'if' statement. + { + // To consider: Make this algorithm work more like DoInsertValue whereby a pointer to value is used. + const value_type temp = value; + const size_type nExtra = static_cast(mpEnd - position); + const pointer pEnd = mpEnd; + + if(n < nExtra) + { + eastl::uninitialized_copy_ptr(mpEnd - n, mpEnd, mpEnd); + mpEnd += n; + eastl::copy_backward(position, pEnd - n, pEnd); // We need copy_backward because of potential overlap issues. + eastl::fill(position, position + n, temp); + } + else + { + eastl::uninitialized_fill_n_ptr(mpEnd, n - nExtra, temp); + mpEnd += n - nExtra; + eastl::uninitialized_copy_ptr(position, pEnd, mpEnd); + mpEnd += nExtra; + eastl::fill(position, pEnd, temp); + } + } + } + else // else n > capacity + { + const size_type nPrevSize = size_type(mpEnd - mpBegin); + const size_type nGrowSize = GetNewCapacity(nPrevSize); + const size_type nNewSize = nGrowSize > (nPrevSize + n) ? nGrowSize : (nPrevSize + n); + pointer const pNewData = DoAllocate(nNewSize); + +#if EASTL_EXCEPTIONS_ENABLED + pointer pNewEnd = pNewData; + try + { + pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + eastl::uninitialized_fill_n_ptr(pNewEnd, n, value); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, pNewEnd + n); + } + catch(...) + { + DoDestroyValues(pNewData, pNewEnd); + DoFree(pNewData, nNewSize); + throw; + } +#else + pointer pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + eastl::uninitialized_fill_n_ptr(pNewEnd, n, value); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, pNewEnd + n); +#endif + + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + mpBegin = pNewData; + mpEnd = pNewEnd; + mpCapacity = pNewData + nNewSize; + } + } + + + template + void vector::DoInsertValue(iterator position, const value_type& value) + { +#if EASTL_ASSERT_ENABLED + if(EASTL_UNLIKELY((position < mpBegin) || (position > mpEnd))) + EASTL_FAIL_MSG("vector::insert -- invalid position"); +#endif + + if(mpEnd != mpCapacity) // If size < capacity ... + { + // EASTL_ASSERT(position < mpEnd); // We don't call this function unless position is less than end, and the code directly below relies on this. + // We need to take into account the possibility that value may come from within the vector itself. + const T* pValue = &value; + if((pValue >= position) && (pValue < mpEnd)) // If value comes from within the range to be moved... + ++pValue; + ::new(mpEnd) value_type(*(mpEnd - 1)); + eastl::copy_backward(position, mpEnd - 1, mpEnd); // We need copy_backward because of potential overlap issues. + *position = *pValue; + ++mpEnd; + } + else // else (size == capacity) + { + const size_type nPrevSize = size_type(mpEnd - mpBegin); + const size_type nNewSize = GetNewCapacity(nPrevSize); + pointer const pNewData = DoAllocate(nNewSize); + +#if EASTL_EXCEPTIONS_ENABLED + pointer pNewEnd = pNewData; + try + { + pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + ::new(pNewEnd) value_type(value); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, ++pNewEnd); + } + catch(...) + { + DoDestroyValues(pNewData, pNewEnd); + DoFree(pNewData, nNewSize); + throw; + } +#else + pointer pNewEnd = eastl::uninitialized_copy_ptr(mpBegin, position, pNewData); + ::new(pNewEnd) value_type(value); + pNewEnd = eastl::uninitialized_copy_ptr(position, mpEnd, ++pNewEnd); +#endif + + DoDestroyValues(mpBegin, mpEnd); + DoFree(mpBegin, (size_type)(mpCapacity - mpBegin)); + + mpBegin = pNewData; + mpEnd = pNewEnd; + mpCapacity = pNewData + nNewSize; + } + } + + + template + inline bool vector::validate() const + { + if(mpEnd < mpBegin) + return false; + if(mpCapacity < mpEnd) + return false; + return true; + } + + + template + inline int vector::validate_iterator(const_iterator i) const + { + if(i >= mpBegin) + { + if(i < mpEnd) + return (isf_valid | isf_current | isf_can_dereference); + + if(i <= mpEnd) + return (isf_valid | isf_current); + } + + return isf_none; + } + + + + /////////////////////////////////////////////////////////////////////// + // global operators + /////////////////////////////////////////////////////////////////////// + + template + inline bool operator==(const vector& a, const vector& b) + { + return ((a.size() == b.size()) && equal(a.begin(), a.end(), b.begin())); + } + + + template + inline bool operator!=(const vector& a, const vector& b) + { + return ((a.size() != b.size()) || !equal(a.begin(), a.end(), b.begin())); + } + + + template + inline bool operator<(const vector& a, const vector& b) + { + return lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); + } + + + template + inline bool operator>(const vector& a, const vector& b) + { + return b < a; + } + + + template + inline bool operator<=(const vector& a, const vector& b) + { + return !(b < a); + } + + + template + inline bool operator>=(const vector& a, const vector& b) + { + return !(a < b); + } + + + template + inline void swap(vector& a, vector& b) + { + a.swap(b); + } + + +} // namespace eastl + + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + + +#endif // Header include guard + + + + + + + + + + diff --git a/lib/eastl/include/EASTL/vector_map.h b/lib/eastl/include/EASTL/vector_map.h new file mode 100644 index 0000000..c20518c --- /dev/null +++ b/lib/eastl/include/EASTL/vector_map.h @@ -0,0 +1,248 @@ +#ifndef EASTL_VECTOR_MAP_H +#define EASTL_VECTOR_MAP_H + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace eastl { + +namespace detail { + +template +struct compare_impl { + typedef Pair pair_type; + typedef typename pair_type::first_type first_argument_type; + + compare_impl() {} + compare_impl(Compare const& src) : m_cmp(src) {} + + bool operator()(first_argument_type const& lhs, first_argument_type const& rhs) const + { return Compare()(lhs, rhs); } + bool operator()(pair_type const& lhs, pair_type const& rhs) const + { return operator()(lhs.first, rhs.first); } + bool operator()(pair_type const& lhs, first_argument_type const& rhs) const + { return operator()(lhs.first, rhs); } + bool operator()(first_argument_type const& lhs, pair_type const& rhs) const + { return operator()(lhs, rhs.first); } + + operator Compare() const { return m_cmp; } + void swap(compare_impl& rhs) { + using ::eastl::swap; + swap(m_cmp, rhs.m_cmp); + } + private: + Compare m_cmp; +}; // struct compare_impl + +} // namespace detail + +template, class A = EASTLAllocatorType> +class vector_map { + public: + typedef K key_type; + typedef V mapped_type; + typedef ::eastl::pair value_type; + typedef C key_compare; + typedef A allocator_type; + + typedef ::eastl::vector base_type; + private: + typedef detail::compare_impl compare_impl_type; + + base_type m_base; + detail::compare_impl m_cmp; + public: + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + + typedef typename base_type::size_type size_type; + typedef typename base_type::difference_type difference_type; + + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; + typedef typename base_type::pointer pointer; + typedef typename base_type::const_pointer const_pointer;; + + static const size_type kMaxSize = base_type::kMaxSize; + + class value_compare { + friend class vector_map; + key_compare const m_cmp; + protected: + value_compare(key_compare pred) : m_cmp(pred) {} + public: + bool operator()(value_type const& lhs, value_type const& rhs) const + { return m_cmp(lhs.first, rhs.first); } + }; // struct value_compare + + explicit vector_map(key_compare const& cmp = key_compare(), allocator_type const& alloc = EASTL_VECTOR_DEFAULT_ALLOCATOR) + : m_base(alloc), m_cmp(cmp) {} + template + vector_map(InputIterator first, InputIterator last, + key_compare const& cmp = key_compare(), + allocator_type const& alloc = EASTL_VECTOR_DEFAULT_ALLOCATOR) + : m_base(alloc), m_cmp(cmp) + { + ::eastl::map const tmp(first, last); + m_base.reserve(tmp.size()); + ::eastl::copy(tmp.begin(), tmp.end(), ::eastl::back_inserter(m_base)); + } + + vector_map& operator =(vector_map const& rhs) { + vector_map(rhs).swap(*this); + return *this; + } + + iterator begin() { return m_base.begin(); } + iterator end() { return m_base.end(); } + reverse_iterator rbegin() { return m_base.rbegin(); } + reverse_iterator rend() { return m_base.rend(); } + + const_iterator begin() const { return m_base.begin(); } + const_iterator end() const { return m_base.end(); } + const_reverse_iterator rbegin() const { return m_base.rbegin(); } + const_reverse_iterator rend() const { return m_base.rend(); } + + void clear() { m_base.clear(); } + + bool empty() const { return m_base.empty(); } + size_type size() const { return m_base.size(); } + size_type max_size() { return base_type::kMaxSize; } + + mapped_type& operator[](key_type const& key) { + return insert(value_type(key, mapped_type())).first->second; + } + + ::eastl::pair insert(value_type const& val) { + iterator const i(lower_bound(val.first)); + + return (i == end() || m_cmp(val.first, i->first)) + ? ::eastl::make_pair(m_base.insert(i, val), true) + : ::eastl::make_pair(i, false) + ; + } + iterator insert(iterator const pos, value_type const& val) { + return + ((pos == begin() || m_cmp(*(pos-1), val)) && + (pos == end() || m_cmp(val, *pos))) + ? m_base.insert(pos, val) + : insert(val).first + ; + } + template + void insert(InputIterator first, InputIterator const last) + { for(; first != last; ++first) insert(*first); } + + void erase(iterator const pos) { m_base.erase(pos); } + void erase(iterator const first, iterator const last) + { m_base.erase(first, last); } + size_type erase(key_type const& k) { + iterator const i(find(k)); + if(i == end()) return 0; + else { erase(i); return 1; } + } + + void swap(vector_map& other) { + m_base.swap(other.m_base); + m_cmp.swap(other.m_cmp); + } + + allocator_type& get_allocator() { return m_base.get_allocator(); } + void set_allocator(allocator_type const& alloc) { m_base.set_allocator(alloc); } + + key_compare key_comp() const { return static_cast(m_cmp); } + value_compare value_comp() const { return value_compare(m_cmp); } + + iterator find(key_type const& k) { + iterator const i(lower_bound(k)); + return (i != end() && m_cmp(k, i->first))? end() : i; + } + const_iterator find(key_type const& k) const { + const_iterator const i(lower_bound(k)); + return (i != end() && m_cmp(k, i->first))? end() : i; + } + size_type count(key_type const& k) const { return find(k) != end()? 1 : 0; } + iterator lower_bound(key_type const& k) { + return ::eastl::lower_bound(begin(), end(), k, m_cmp); + } + const_iterator lower_bound(key_type const& k) const { + return ::eastl::lower_bound(begin(), end(), k, m_cmp); + } + iterator upper_bound(key_type const& k) { + return ::eastl::upper_bound(begin(), end(), k, m_cmp); + } + const_iterator upper_bound(key_type const& k) const { + return ::eastl::upper_bound(begin(), end(), k, m_cmp); + } + + ::eastl::pair equal_range(key_type const& k) { + return ::eastl::equal_range(begin(), end(), k, m_cmp); + } + ::eastl::pair equal_range(key_type const& k) const { + return ::eastl::equal_range(begin(), end(), k, m_cmp); + } + + template + friend bool operator==(vector_map const& lhs, + vector_map const& rhs); + template + friend bool operator!=(vector_map const& lhs, + vector_map const& rhs); + template + friend bool operator<(vector_map const& lhs, + vector_map const& rhs); + template + friend bool operator>(vector_map const& lhs, + vector_map const& rhs); + template + friend bool operator>=(vector_map const& lhs, + vector_map const& rhs); + template + friend bool operator<=(vector_map const& lhs, + vector_map const& rhs); +}; // class vector_map + +template +inline bool operator==(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base == rhs.m_base; } +template +inline bool operator!=(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base != rhs.m_base; } +template +inline bool operator<(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base < rhs.m_base; } +template +inline bool operator>(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base > rhs.m_base; } +template +inline bool operator>=(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base >= rhs.m_base; } +template +inline bool operator<=(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.m_base <= rhs.m_base; } + +template +void swap(vector_map const& lhs, + vector_map const& rhs) +{ return lhs.swap(rhs); } + +} // namespace eastl + +#endif // EASTL_VECTOR_MAP_H diff --git a/lib/eastl/src/allocator.cpp b/lib/eastl/src/allocator.cpp new file mode 100644 index 0000000..5714430 --- /dev/null +++ b/lib/eastl/src/allocator.cpp @@ -0,0 +1,87 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/allocator.cpp +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + +#include +#include + + +/////////////////////////////////////////////////////////////////////////////// +// ReadMe +// +// This file implements the default application allocator. +// You can replace this allocator.cpp file with a different one, +// you can define EASTL_USER_DEFINED_ALLOCATOR below to ignore this file, +// or you can modify the EASTL config.h file to redefine how allocators work. +/////////////////////////////////////////////////////////////////////////////// + + +#ifndef EASTL_USER_DEFINED_ALLOCATOR // If the user hasn't declared that he has defined an allocator implementation elsewhere... + + namespace eastl + { + + /// gDefaultAllocator + /// Default global allocator instance. + EASTL_API allocator gDefaultAllocator; + EASTL_API allocator* gpDefaultAllocator = &gDefaultAllocator; + + EASTL_API allocator* GetDefaultAllocator() + { + return gpDefaultAllocator; + } + + EASTL_API allocator* SetDefaultAllocator(allocator* pAllocator) + { + allocator* const pPrevAllocator = gpDefaultAllocator; + gpDefaultAllocator = pAllocator; + return pPrevAllocator; + } + + } // namespace eastl + + +#endif // EASTL_USER_DEFINED_ALLOCATOR + + + + + + + + + + + diff --git a/lib/eastl/src/assert.cpp b/lib/eastl/src/assert.cpp new file mode 100644 index 0000000..51975e6 --- /dev/null +++ b/lib/eastl/src/assert.cpp @@ -0,0 +1,136 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/assert.cpp +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + + +#include +#include +#include + +#if defined(EA_PLATFORM_MICROSOFT) + #pragma warning(push, 0) + #if defined _MSC_VER + #include + #endif + #if defined(EA_PLATFORM_WINDOWS) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN + #endif + #include + #elif defined(EA_PLATFORM_XENON) + #include + #endif + #pragma warning(pop) +#else + #include +#endif + + + + +namespace eastl +{ + + /// gpAssertionFailureFunction + /// + /// Global assertion failure function pointer. Set by SetAssertionFailureFunction. + /// + EASTL_API EASTL_AssertionFailureFunction gpAssertionFailureFunction = AssertionFailureFunctionDefault; + EASTL_API void* gpAssertionFailureFunctionContext = NULL; + + + + /// SetAssertionFailureFunction + /// + /// Sets the function called when an assertion fails. If this function is not called + /// by the user, a default function will be used. The user may supply a context parameter + /// which will be passed back to the user in the function call. This is typically used + /// to store a C++ 'this' pointer, though other things are possible. + /// + /// There is no thread safety here, so the user needs to externally make sure that + /// this function is not called in a thread-unsafe way. The easiest way to do this is + /// to just call this function once from the main thread on application startup. + /// + EASTL_API void SetAssertionFailureFunction(EASTL_AssertionFailureFunction pAssertionFailureFunction, void* pContext) + { + gpAssertionFailureFunction = pAssertionFailureFunction; + gpAssertionFailureFunctionContext = pContext; + } + + + + /// AssertionFailureFunctionDefault + /// + EASTL_API void AssertionFailureFunctionDefault(const char* pExpression, void* /*pContext*/) + { + (void)pExpression; +#if defined(EA_DEBUG) || defined(_DEBUG) + // We cannot use puts() because it appends a newline. + // We cannot use printf(pExpression) because pExpression might have formatting statements. + #if defined(EA_PLATFORM_MICROSOFT) + OutputDebugStringA(pExpression); + #else + printf("%s", pExpression); // Write the message to stdout, which happens to be the trace view for many console debug machines. + #endif +#endif + EASTL_DEBUG_BREAK(); + } + + + /// AssertionFailure + /// + EASTL_API void AssertionFailure(const char* pExpression) + { + if(gpAssertionFailureFunction) + gpAssertionFailureFunction(pExpression, gpAssertionFailureFunctionContext); + } + + +} // namespace eastl + + + + + + + + + + + + + + + diff --git a/lib/eastl/src/fixed_pool.cpp b/lib/eastl/src/fixed_pool.cpp new file mode 100644 index 0000000..38f292b --- /dev/null +++ b/lib/eastl/src/fixed_pool.cpp @@ -0,0 +1,102 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/fixed_pool.cpp +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + + +#include +#include + + + +namespace eastl +{ + + + void fixed_pool_base::init(void* pMemory, size_t memorySize, size_t nodeSize, + size_t alignment, size_t /*alignmentOffset*/) + { + // To do: Support alignmentOffset. + + #if EASTL_FIXED_SIZE_TRACKING_ENABLED + mnCurrentSize = 0; + mnPeakSize = 0; + #endif + + if(pMemory) + { + // Assert that alignment is a power of 2 value (e.g. 1, 2, 4, 8, 16, etc.) + EASTL_ASSERT((alignment & (alignment - 1)) == 0); + + // Make sure alignment is a valid value. + if(alignment < 1) + alignment = 1; + + mpNext = (Link*)(((uintptr_t)pMemory + (alignment - 1)) & ~(alignment - 1)); + memorySize -= (uintptr_t)mpNext - (uintptr_t)pMemory; + pMemory = mpNext; + + // The node size must be at least as big as a Link, which itself is sizeof(void*). + if(nodeSize < sizeof(Link)) + nodeSize = ((sizeof(Link) + (alignment - 1))) & ~(alignment - 1); + + // If the user passed in a memory size that wasn't a multiple of the node size, + // we need to chop down the memory size so that the last node is not a whole node. + memorySize = (memorySize / nodeSize) * nodeSize; + + mpCapacity = (Link*)((uintptr_t)pMemory + memorySize); + mpHead = NULL; + mnNodeSize = nodeSize; + } + } + + +} // namespace eastl + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/src/hashtable.cpp b/lib/eastl/src/hashtable.cpp new file mode 100644 index 0000000..4eb917c --- /dev/null +++ b/lib/eastl/src/hashtable.cpp @@ -0,0 +1,233 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/hashtable.cpp +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + + +#include +#include +#include // Not all compilers support and std::ceil(), which we need below. +#include + + +#ifdef _MSC_VER + #pragma warning(disable: 4267) // 'argument' : conversion from 'size_t' to 'const uint32_t', possible loss of data. This is a bogus warning resulting from a bug in VC++. +#endif + + +namespace eastl +{ + + /// gpEmptyBucketArray + /// + /// A shared representation of an empty hash table. This is present so that + /// a new empty hashtable allocates no memory. It has two entries, one for + /// the first lone empty (NULL) bucket, and one for the non-NULL trailing sentinel. + /// + EASTL_API void* gpEmptyBucketArray[2] = { NULL, (void*)uintptr_t(~0) }; + + + + /// gPrimeNumberArray + /// + /// This is an array of prime numbers. This is the same set of prime + /// numbers suggested by the C++ standard proposal. These are numbers + /// which are separated by 8% per entry. + /// + /// To consider: Allow the user to specify their own prime number array. + /// + const uint32_t gPrimeNumberArray[] = + { + 2u, 3u, 5u, 7u, 11u, 13u, 17u, 19u, 23u, 29u, 31u, + 37u, 41u, 43u, 47u, 53u, 59u, 61u, 67u, 71u, 73u, 79u, + 83u, 89u, 97u, 103u, 109u, 113u, 127u, 137u, 139u, 149u, + 157u, 167u, 179u, 193u, 199u, 211u, 227u, 241u, 257u, + 277u, 293u, 313u, 337u, 359u, 383u, 409u, 439u, 467u, + 503u, 541u, 577u, 619u, 661u, 709u, 761u, 823u, 887u, + 953u, 1031u, 1109u, 1193u, 1289u, 1381u, 1493u, 1613u, + 1741u, 1879u, 2029u, 2179u, 2357u, 2549u, 2753u, 2971u, + 3209u, 3469u, 3739u, 4027u, 4349u, 4703u, 5087u, 5503u, + 5953u, 6427u, 6949u, 7517u, 8123u, 8783u, 9497u, 10273u, + 11113u, 12011u, 12983u, 14033u, 15173u, 16411u, 17749u, + 19183u, 20753u, 22447u, 24281u, 26267u, 28411u, 30727u, + 33223u, 35933u, 38873u, 42043u, 45481u, 49201u, 53201u, + 57557u, 62233u, 67307u, 72817u, 78779u, 85229u, 92203u, + 99733u, 107897u, 116731u, 126271u, 136607u, 147793u, + 159871u, 172933u, 187091u, 202409u, 218971u, 236897u, + 256279u, 277261u, 299951u, 324503u, 351061u, 379787u, + 410857u, 444487u, 480881u, 520241u, 562841u, 608903u, + 658753u, 712697u, 771049u, 834181u, 902483u, 976369u, + 1056323u, 1142821u, 1236397u, 1337629u, 1447153u, 1565659u, + 1693859u, 1832561u, 1982627u, 2144977u, 2320627u, 2510653u, + 2716249u, 2938679u, 3179303u, 3439651u, 3721303u, 4026031u, + 4355707u, 4712381u, 5098259u, 5515729u, 5967347u, 6456007u, + 6984629u, 7556579u, 8175383u, 8844859u, 9569143u, 10352717u, + 11200489u, 12117689u, 13109983u, 14183539u, 15345007u, + 16601593u, 17961079u, 19431899u, 21023161u, 22744717u, + 24607243u, 26622317u, 28802401u, 31160981u, 33712729u, + 36473443u, 39460231u, 42691603u, 46187573u, 49969847u, + 54061849u, 58488943u, 63278561u, 68460391u, 74066549u, + 80131819u, 86693767u, 93793069u, 101473717u, 109783337u, + 118773397u, 128499677u, 139022417u, 150406843u, 162723577u, + 176048909u, 190465427u, 206062531u, 222936881u, 241193053u, + 260944219u, 282312799u, 305431229u, 330442829u, 357502601u, + 386778277u, 418451333u, 452718089u, 489790921u, 529899637u, + 573292817u, 620239453u, 671030513u, 725980837u, 785430967u, + 849749479u, 919334987u, 994618837u, 1076067617u, 1164186217u, + 1259520799u, 1362662261u, 1474249943u, 1594975441u, + 1725587117u, 1866894511u, 2019773507u, 2185171673u, + 2364114217u, 2557710269u, 2767159799u, 2993761039u, + 3238918481u, 3504151727u, 3791104843u, 4101556399u, + 4294967291u, + 4294967291u // Sentinel so we don't have to test result of lower_bound + }; + + + /// kPrimeCount + /// + /// The number of prime numbers in gPrimeNumberArray. + /// + const uint32_t kPrimeCount = (sizeof(gPrimeNumberArray) / sizeof(gPrimeNumberArray[0]) - 1); + + + /// GetPrevBucketCountOnly + /// Return a bucket count no greater than nBucketCountHint. + /// + uint32_t prime_rehash_policy::GetPrevBucketCountOnly(uint32_t nBucketCountHint) + { + const uint32_t nPrime = *(eastl::upper_bound(gPrimeNumberArray, gPrimeNumberArray + kPrimeCount, nBucketCountHint) - 1); + return nPrime; + } + + + /// GetPrevBucketCount + /// Return a bucket count no greater than nBucketCountHint. + /// This function has a side effect of updating mnNextResize. + /// + uint32_t prime_rehash_policy::GetPrevBucketCount(uint32_t nBucketCountHint) const + { + const uint32_t nPrime = *(eastl::upper_bound(gPrimeNumberArray, gPrimeNumberArray + kPrimeCount, nBucketCountHint) - 1); + + mnNextResize = (uint32_t)ceil(nPrime * floor(mfMaxLoadFactor)); + return nPrime; + } + + + /// GetNextBucketCount + /// Return a prime no smaller than nBucketCountHint. + /// This function has a side effect of updating mnNextResize. + /// + uint32_t prime_rehash_policy::GetNextBucketCount(uint32_t nBucketCountHint) const + { + const uint32_t nPrime = *eastl::lower_bound(gPrimeNumberArray, gPrimeNumberArray + kPrimeCount, nBucketCountHint); + + mnNextResize = (uint32_t)ceil(nPrime * floor(mfMaxLoadFactor)); + return nPrime; + } + + + /// GetBucketCount + /// Return the smallest prime p such that alpha p >= nElementCount, where alpha + /// is the load factor. This function has a side effect of updating mnNextResize. + /// + uint32_t prime_rehash_policy::GetBucketCount(uint32_t nElementCount) const + { + const uint32_t nMinBucketCount = (uint32_t)(nElementCount / floor(mfMaxLoadFactor)); + const uint32_t nPrime = *eastl::lower_bound(gPrimeNumberArray, gPrimeNumberArray + kPrimeCount, nMinBucketCount); + + mnNextResize = (uint32_t)ceil(nPrime * floor(mfMaxLoadFactor)); + return nPrime; + } + + + /// GetRehashRequired + /// Finds the smallest prime p such that alpha p > nElementCount + nElementAdd. + /// If p > nBucketCount, return pair(true, p); otherwise return + /// pair(false, 0). In principle this isn't very different from GetBucketCount. + /// This function has a side effect of updating mnNextResize. + /// + eastl::pair + prime_rehash_policy::GetRehashRequired(uint32_t nBucketCount, uint32_t nElementCount, uint32_t nElementAdd) const + { + if((nElementCount + nElementAdd) > mnNextResize) // It is significant that we specify > next resize and not >= next resize. + { + if(nBucketCount == 1) // We force rehashing to occur if the bucket count is < 2. + nBucketCount = 0; + + float fMinBucketCount = (float)(nElementCount + nElementAdd) / mfMaxLoadFactor; + + if(fMinBucketCount > (float)nBucketCount) + { + fMinBucketCount = eastl::max_alt(fMinBucketCount, mfGrowthFactor * (float)nBucketCount); + const uint32_t nPrime = *eastl::lower_bound(gPrimeNumberArray, gPrimeNumberArray + kPrimeCount, (uint32_t)fMinBucketCount); + mnNextResize = (uint32_t)ceil(nPrime * floor(mfMaxLoadFactor)); + + return eastl::pair(true, nPrime); + } + else + { + mnNextResize = (uint32_t)ceil(nBucketCount * floor(mfMaxLoadFactor)); + return eastl::pair(false, (uint32_t)0); + } + } + + return eastl::pair(false, (uint32_t)0); + } + + +} // namespace eastl + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/src/red_black_tree.cpp b/lib/eastl/src/red_black_tree.cpp new file mode 100644 index 0000000..d6690c6 --- /dev/null +++ b/lib/eastl/src/red_black_tree.cpp @@ -0,0 +1,535 @@ +/* +Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/red_black_tree.cpp +// +// Written and maintained by Paul Pedriana - 2005. +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// The tree insert and erase functions below are based on the original +// HP STL tree functions. Use of these functions was been approved by +// EA legal on November 4, 2005 and the approval documentation is available +// from the EASTL maintainer or from the EA legal deparatment on request. +// +// Copyright (c) 1994 +// Hewlett-Packard Company +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appear in all copies and +// that both that copyright notice and this permission notice appear +// in supporting documentation. Hewlett-Packard Company makes no +// representations about the suitability of this software for any +// purpose. It is provided "as is" without express or implied warranty. +/////////////////////////////////////////////////////////////////////////////// + + + + +#include +#include +#include + + + +namespace eastl +{ + // Forward declarations + rbtree_node_base* RBTreeRotateLeft(rbtree_node_base* pNode, rbtree_node_base* pNodeRoot); + rbtree_node_base* RBTreeRotateRight(rbtree_node_base* pNode, rbtree_node_base* pNodeRoot); + + + + /// RBTreeIncrement + /// Returns the next item in a sorted red-black tree. + /// + EASTL_API rbtree_node_base* RBTreeIncrement(const rbtree_node_base* pNode) + { + if(pNode->mpNodeRight) + { + pNode = pNode->mpNodeRight; + + while(pNode->mpNodeLeft) + pNode = pNode->mpNodeLeft; + } + else + { + rbtree_node_base* pNodeTemp = pNode->mpNodeParent; + + while(pNode == pNodeTemp->mpNodeRight) + { + pNode = pNodeTemp; + pNodeTemp = pNodeTemp->mpNodeParent; + } + + if(pNode->mpNodeRight != pNodeTemp) + pNode = pNodeTemp; + } + + return const_cast(pNode); + } + + + + /// RBTreeIncrement + /// Returns the previous item in a sorted red-black tree. + /// + EASTL_API rbtree_node_base* RBTreeDecrement(const rbtree_node_base* pNode) + { + if((pNode->mpNodeParent->mpNodeParent == pNode) && (pNode->mColor == kRBTreeColorRed)) + return pNode->mpNodeRight; + else if(pNode->mpNodeLeft) + { + rbtree_node_base* pNodeTemp = pNode->mpNodeLeft; + + while(pNodeTemp->mpNodeRight) + pNodeTemp = pNodeTemp->mpNodeRight; + + return pNodeTemp; + } + + rbtree_node_base* pNodeTemp = pNode->mpNodeParent; + + while(pNode == pNodeTemp->mpNodeLeft) + { + pNode = pNodeTemp; + pNodeTemp = pNodeTemp->mpNodeParent; + } + + return const_cast(pNodeTemp); + } + + + + /// RBTreeGetBlackCount + /// Counts the number of black nodes in an red-black tree, from pNode down to the given bottom node. + /// We don't count red nodes because red-black trees don't really care about + /// red node counts; it is black node counts that are significant in the + /// maintenance of a balanced tree. + /// + EASTL_API size_t RBTreeGetBlackCount(const rbtree_node_base* pNodeTop, const rbtree_node_base* pNodeBottom) + { + size_t nCount = 0; + + for(; pNodeBottom; pNodeBottom = pNodeBottom->mpNodeParent) + { + if(pNodeBottom->mColor == kRBTreeColorBlack) + ++nCount; + + if(pNodeBottom == pNodeTop) + break; + } + + return nCount; + } + + + /// RBTreeRotateLeft + /// Does a left rotation about the given node. + /// If you want to understand tree rotation, any book on algorithms will + /// discussion the topic in good detail. + rbtree_node_base* RBTreeRotateLeft(rbtree_node_base* pNode, rbtree_node_base* pNodeRoot) + { + rbtree_node_base* const pNodeTemp = pNode->mpNodeRight; + + pNode->mpNodeRight = pNodeTemp->mpNodeLeft; + + if(pNodeTemp->mpNodeLeft) + pNodeTemp->mpNodeLeft->mpNodeParent = pNode; + pNodeTemp->mpNodeParent = pNode->mpNodeParent; + + if(pNode == pNodeRoot) + pNodeRoot = pNodeTemp; + else if(pNode == pNode->mpNodeParent->mpNodeLeft) + pNode->mpNodeParent->mpNodeLeft = pNodeTemp; + else + pNode->mpNodeParent->mpNodeRight = pNodeTemp; + + pNodeTemp->mpNodeLeft = pNode; + pNode->mpNodeParent = pNodeTemp; + + return pNodeRoot; + } + + + + /// RBTreeRotateRight + /// Does a right rotation about the given node. + /// If you want to understand tree rotation, any book on algorithms will + /// discussion the topic in good detail. + rbtree_node_base* RBTreeRotateRight(rbtree_node_base* pNode, rbtree_node_base* pNodeRoot) + { + rbtree_node_base* const pNodeTemp = pNode->mpNodeLeft; + + pNode->mpNodeLeft = pNodeTemp->mpNodeRight; + + if(pNodeTemp->mpNodeRight) + pNodeTemp->mpNodeRight->mpNodeParent = pNode; + pNodeTemp->mpNodeParent = pNode->mpNodeParent; + + if(pNode == pNodeRoot) + pNodeRoot = pNodeTemp; + else if(pNode == pNode->mpNodeParent->mpNodeRight) + pNode->mpNodeParent->mpNodeRight = pNodeTemp; + else + pNode->mpNodeParent->mpNodeLeft = pNodeTemp; + + pNodeTemp->mpNodeRight = pNode; + pNode->mpNodeParent = pNodeTemp; + + return pNodeRoot; + } + + + + + /// RBTreeInsert + /// Insert a node into the tree and rebalance the tree as a result of the + /// disturbance the node introduced. + /// + EASTL_API void RBTreeInsert(rbtree_node_base* pNode, + rbtree_node_base* pNodeParent, + rbtree_node_base* pNodeAnchor, + RBTreeSide insertionSide) + { + rbtree_node_base*& pNodeRootRef = pNodeAnchor->mpNodeParent; + + // Initialize fields in new node to insert. + pNode->mpNodeParent = pNodeParent; + pNode->mpNodeRight = NULL; + pNode->mpNodeLeft = NULL; + pNode->mColor = kRBTreeColorRed; + + // Insert the node. + if(insertionSide == kRBTreeSideLeft) + { + pNodeParent->mpNodeLeft = pNode; // Also makes (leftmost = pNode) when (pNodeParent == pNodeAnchor) + + if(pNodeParent == pNodeAnchor) + { + pNodeAnchor->mpNodeParent = pNode; + pNodeAnchor->mpNodeRight = pNode; + } + else if(pNodeParent == pNodeAnchor->mpNodeLeft) + pNodeAnchor->mpNodeLeft = pNode; // Maintain leftmost pointing to min node + } + else + { + pNodeParent->mpNodeRight = pNode; + + if(pNodeParent == pNodeAnchor->mpNodeRight) + pNodeAnchor->mpNodeRight = pNode; // Maintain rightmost pointing to max node + } + + // Rebalance the tree. + while((pNode != pNodeRootRef) && (pNode->mpNodeParent->mColor == kRBTreeColorRed)) + { + rbtree_node_base* const pNodeParentParent = pNode->mpNodeParent->mpNodeParent; + + if(pNode->mpNodeParent == pNodeParentParent->mpNodeLeft) + { + rbtree_node_base* const pNodeTemp = pNodeParentParent->mpNodeRight; + + if(pNodeTemp && (pNodeTemp->mColor == kRBTreeColorRed)) + { + pNode->mpNodeParent->mColor = kRBTreeColorBlack; + pNodeTemp->mColor = kRBTreeColorBlack; + pNodeParentParent->mColor = kRBTreeColorRed; + pNode = pNodeParentParent; + } + else + { + if(pNode == pNode->mpNodeParent->mpNodeRight) + { + pNode = pNode->mpNodeParent; + pNodeRootRef = RBTreeRotateLeft(pNode, pNodeRootRef); + } + + pNode->mpNodeParent->mColor = kRBTreeColorBlack; + pNodeParentParent->mColor = kRBTreeColorRed; + pNodeRootRef = RBTreeRotateRight(pNodeParentParent, pNodeRootRef); + } + } + else + { + rbtree_node_base* const pNodeTemp = pNodeParentParent->mpNodeLeft; + + if(pNodeTemp && (pNodeTemp->mColor == kRBTreeColorRed)) + { + pNode->mpNodeParent->mColor = kRBTreeColorBlack; + pNodeTemp->mColor = kRBTreeColorBlack; + pNodeParentParent->mColor = kRBTreeColorRed; + pNode = pNodeParentParent; + } + else + { + if(pNode == pNode->mpNodeParent->mpNodeLeft) + { + pNode = pNode->mpNodeParent; + pNodeRootRef = RBTreeRotateRight(pNode, pNodeRootRef); + } + + pNode->mpNodeParent->mColor = kRBTreeColorBlack; + pNodeParentParent->mColor = kRBTreeColorRed; + pNodeRootRef = RBTreeRotateLeft(pNodeParentParent, pNodeRootRef); + } + } + } + + pNodeRootRef->mColor = kRBTreeColorBlack; + + } // RBTreeInsert + + + + + /// RBTreeErase + /// Erase a node from the tree. + /// + EASTL_API void RBTreeErase(rbtree_node_base* pNode, rbtree_node_base* pNodeAnchor) + { + rbtree_node_base*& pNodeRootRef = pNodeAnchor->mpNodeParent; + rbtree_node_base*& pNodeLeftmostRef = pNodeAnchor->mpNodeLeft; + rbtree_node_base*& pNodeRightmostRef = pNodeAnchor->mpNodeRight; + rbtree_node_base* pNodeSuccessor = pNode; + rbtree_node_base* pNodeChild = NULL; + rbtree_node_base* pNodeChildParent = NULL; + + if(pNodeSuccessor->mpNodeLeft == NULL) // pNode has at most one non-NULL child. + pNodeChild = pNodeSuccessor->mpNodeRight; // pNodeChild might be null. + else if(pNodeSuccessor->mpNodeRight == NULL) // pNode has exactly one non-NULL child. + pNodeChild = pNodeSuccessor->mpNodeLeft; // pNodeChild is not null. + else + { + // pNode has two non-null children. Set pNodeSuccessor to pNode's successor. pNodeChild might be NULL. + pNodeSuccessor = pNodeSuccessor->mpNodeRight; + + while(pNodeSuccessor->mpNodeLeft) + pNodeSuccessor = pNodeSuccessor->mpNodeLeft; + + pNodeChild = pNodeSuccessor->mpNodeRight; + } + + // Here we remove pNode from the tree and fix up the node pointers appropriately around it. + if(pNodeSuccessor == pNode) // If pNode was a leaf node (had both NULL children)... + { + pNodeChildParent = pNodeSuccessor->mpNodeParent; // Assign pNodeReplacement's parent. + + if(pNodeChild) + pNodeChild->mpNodeParent = pNodeSuccessor->mpNodeParent; + + if(pNode == pNodeRootRef) // If the node being deleted is the root node... + pNodeRootRef = pNodeChild; // Set the new root node to be the pNodeReplacement. + else + { + if(pNode == pNode->mpNodeParent->mpNodeLeft) // If pNode is a left node... + pNode->mpNodeParent->mpNodeLeft = pNodeChild; // Make pNode's replacement node be on the same side. + else + pNode->mpNodeParent->mpNodeRight = pNodeChild; + // Now pNode is disconnected from the bottom of the tree (recall that in this pathway pNode was determined to be a leaf). + } + + if(pNode == pNodeLeftmostRef) // If pNode is the tree begin() node... + { + // Because pNode is the tree begin(), pNode->mpNodeLeft must be NULL. + // Here we assign the new begin() (first node). + if(pNode->mpNodeRight) + pNodeLeftmostRef = RBTreeGetMinChild(pNodeChild); + else + pNodeLeftmostRef = pNode->mpNodeParent; // This makes (pNodeLeftmostRef == end()) if (pNode == root node) + } + + if(pNode == pNodeRightmostRef) // If pNode is the tree last (rbegin()) node... + { + // Because pNode is the tree rbegin(), pNode->mpNodeRight must be NULL. + // Here we assign the new rbegin() (last node) + if(pNode->mpNodeLeft) + pNodeRightmostRef = RBTreeGetMaxChild(pNodeChild); + else // pNodeChild == pNode->mpNodeLeft + pNodeRightmostRef = pNode->mpNodeParent; // makes pNodeRightmostRef == &mAnchor if pNode == pNodeRootRef + } + } + else // else (pNodeSuccessor != pNode) + { + // Relink pNodeSuccessor in place of pNode. pNodeSuccessor is pNode's successor. + // We specifically set pNodeSuccessor to be on the right child side of pNode, so fix up the left child side. + pNode->mpNodeLeft->mpNodeParent = pNodeSuccessor; + pNodeSuccessor->mpNodeLeft = pNode->mpNodeLeft; + + if(pNodeSuccessor == pNode->mpNodeRight) // If pNode's successor was at the bottom of the tree... (yes that's effectively what this statement means) + pNodeChildParent = pNodeSuccessor; // Assign pNodeReplacement's parent. + else + { + pNodeChildParent = pNodeSuccessor->mpNodeParent; + + if(pNodeChild) + pNodeChild->mpNodeParent = pNodeChildParent; + + pNodeChildParent->mpNodeLeft = pNodeChild; + + pNodeSuccessor->mpNodeRight = pNode->mpNodeRight; + pNode->mpNodeRight->mpNodeParent = pNodeSuccessor; + } + + if(pNode == pNodeRootRef) + pNodeRootRef = pNodeSuccessor; + else if(pNode == pNode->mpNodeParent->mpNodeLeft) + pNode->mpNodeParent->mpNodeLeft = pNodeSuccessor; + else + pNode->mpNodeParent->mpNodeRight = pNodeSuccessor; + + // Now pNode is disconnected from the tree. + + pNodeSuccessor->mpNodeParent = pNode->mpNodeParent; + eastl::swap(pNodeSuccessor->mColor, pNode->mColor); + } + + // Here we do tree balancing as per the conventional red-black tree algorithm. + if(pNode->mColor == kRBTreeColorBlack) + { + while((pNodeChild != pNodeRootRef) && ((pNodeChild == NULL) || (pNodeChild->mColor == kRBTreeColorBlack))) + { + if(pNodeChild == pNodeChildParent->mpNodeLeft) + { + rbtree_node_base* pNodeTemp = pNodeChildParent->mpNodeRight; + + if(pNodeTemp->mColor == kRBTreeColorRed) + { + pNodeTemp->mColor = kRBTreeColorBlack; + pNodeChildParent->mColor = kRBTreeColorRed; + pNodeRootRef = RBTreeRotateLeft(pNodeChildParent, pNodeRootRef); + pNodeTemp = pNodeChildParent->mpNodeRight; + } + + if(((pNodeTemp->mpNodeLeft == NULL) || (pNodeTemp->mpNodeLeft->mColor == kRBTreeColorBlack)) && + ((pNodeTemp->mpNodeRight == NULL) || (pNodeTemp->mpNodeRight->mColor == kRBTreeColorBlack))) + { + pNodeTemp->mColor = kRBTreeColorRed; + pNodeChild = pNodeChildParent; + pNodeChildParent = pNodeChildParent->mpNodeParent; + } + else + { + if((pNodeTemp->mpNodeRight == NULL) || (pNodeTemp->mpNodeRight->mColor == kRBTreeColorBlack)) + { + pNodeTemp->mpNodeLeft->mColor = kRBTreeColorBlack; + pNodeTemp->mColor = kRBTreeColorRed; + pNodeRootRef = RBTreeRotateRight(pNodeTemp, pNodeRootRef); + pNodeTemp = pNodeChildParent->mpNodeRight; + } + + pNodeTemp->mColor = pNodeChildParent->mColor; + pNodeChildParent->mColor = kRBTreeColorBlack; + + if(pNodeTemp->mpNodeRight) + pNodeTemp->mpNodeRight->mColor = kRBTreeColorBlack; + + pNodeRootRef = RBTreeRotateLeft(pNodeChildParent, pNodeRootRef); + break; + } + } + else + { + // The following is the same as above, with mpNodeRight <-> mpNodeLeft. + rbtree_node_base* pNodeTemp = pNodeChildParent->mpNodeLeft; + + if(pNodeTemp->mColor == kRBTreeColorRed) + { + pNodeTemp->mColor = kRBTreeColorBlack; + pNodeChildParent->mColor = kRBTreeColorRed; + + pNodeRootRef = RBTreeRotateRight(pNodeChildParent, pNodeRootRef); + pNodeTemp = pNodeChildParent->mpNodeLeft; + } + + if(((pNodeTemp->mpNodeRight == NULL) || (pNodeTemp->mpNodeRight->mColor == kRBTreeColorBlack)) && + ((pNodeTemp->mpNodeLeft == NULL) || (pNodeTemp->mpNodeLeft->mColor == kRBTreeColorBlack))) + { + pNodeTemp->mColor = kRBTreeColorRed; + pNodeChild = pNodeChildParent; + pNodeChildParent = pNodeChildParent->mpNodeParent; + } + else + { + if((pNodeTemp->mpNodeLeft == NULL) || (pNodeTemp->mpNodeLeft->mColor == kRBTreeColorBlack)) + { + pNodeTemp->mpNodeRight->mColor = kRBTreeColorBlack; + pNodeTemp->mColor = kRBTreeColorRed; + + pNodeRootRef = RBTreeRotateLeft(pNodeTemp, pNodeRootRef); + pNodeTemp = pNodeChildParent->mpNodeLeft; + } + + pNodeTemp->mColor = pNodeChildParent->mColor; + pNodeChildParent->mColor = kRBTreeColorBlack; + + if(pNodeTemp->mpNodeLeft) + pNodeTemp->mpNodeLeft->mColor = kRBTreeColorBlack; + + pNodeRootRef = RBTreeRotateRight(pNodeChildParent, pNodeRootRef); + break; + } + } + } + + if(pNodeChild) + pNodeChild->mColor = kRBTreeColorBlack; + } + + } // RBTreeErase + + + +} // namespace eastl + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/eastl/src/string.cpp b/lib/eastl/src/string.cpp new file mode 100644 index 0000000..1f4a3ba --- /dev/null +++ b/lib/eastl/src/string.cpp @@ -0,0 +1,71 @@ +/* +Copyright (C) 2009-2010 Electronic Arts, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/////////////////////////////////////////////////////////////////////////////// +// EASTL/string.cpp +// +// Copyright (c) 2005, Electronic Arts. All rights reserved. +// Written and maintained by Paul Pedriana. +/////////////////////////////////////////////////////////////////////////////// + + + +#include +#include +#include + + +namespace eastl +{ + + /// gEmptyString + /// + /// gEmptyString is used for empty strings. This allows us to avoid allocating + /// memory for empty strings without having to add null pointer checks. + /// The downside of this technique is that all empty strings share this same + /// value and if any code makes an error and writes to this value with non-zero, + /// then all existing empty strings will be wrecked and not just the one that + /// was incorrectly overwritten. + EASTL_API EmptyString gEmptyString = { 0 }; + + +} // namespace eastl + + + + + + + + + + + + + + diff --git a/lib/glew/glew.c b/lib/glew/glew.c new file mode 100644 index 0000000..dccce00 --- /dev/null +++ b/lib/glew/glew.c @@ -0,0 +1,15951 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "glew.h" +#if defined(_WIN32) +# include "wglew.h" +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) +# include "glxew.h" +#endif + +/* + * Define glewGetContext and related helper macros. + */ +#ifdef GLEW_MX +# define glewGetContext() ctx +# ifdef _WIN32 +# define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx +# define GLEW_CONTEXT_ARG_VAR_INIT ctx +# define wglewGetContext() ctx +# define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx +# define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx +# else /* _WIN32 */ +# define GLEW_CONTEXT_ARG_DEF_INIT void +# define GLEW_CONTEXT_ARG_VAR_INIT +# define glxewGetContext() ctx +# define GLXEW_CONTEXT_ARG_DEF_INIT void +# define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx +# endif /* _WIN32 */ +# define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx +#else /* GLEW_MX */ +# define GLEW_CONTEXT_ARG_DEF_INIT void +# define GLEW_CONTEXT_ARG_VAR_INIT +# define GLEW_CONTEXT_ARG_DEF_LIST void +# define WGLEW_CONTEXT_ARG_DEF_INIT void +# define WGLEW_CONTEXT_ARG_DEF_LIST void +# define GLXEW_CONTEXT_ARG_DEF_INIT void +# define GLXEW_CONTEXT_ARG_DEF_LIST void +#endif /* GLEW_MX */ + +#if defined(__sgi) || defined (__sun) || defined(GLEW_APPLE_GLX) +#include +#include +#include + +void* dlGetProcAddress (const GLubyte* name) +{ + static void* h = NULL; + static void* gpa; + + if (h == NULL) + { + if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL; + gpa = dlsym(h, "glXGetProcAddress"); + } + + if (gpa != NULL) + return ((void*(*)(const GLubyte*))gpa)(name); + else + return dlsym(h, (const char*)name); +} +#endif /* __sgi || __sun || GLEW_APPLE_GLX */ + +#if defined(__APPLE__) +#include +#include +#include + +#ifdef MAC_OS_X_VERSION_10_3 + +#include + +void* NSGLGetProcAddress (const GLubyte *name) +{ + static void* image = NULL; + if (NULL == image) + { + image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY); + } + if( !image ) return NULL; + void* addr = dlsym(image, (const char*)name); + if( addr ) return addr; +#ifdef GLEW_APPLE_GLX + return dlGetProcAddress( name ); // try next for glx symbols +#else + return NULL; +#endif +} +#else + +#include + +void* NSGLGetProcAddress (const GLubyte *name) +{ + static const struct mach_header* image = NULL; + NSSymbol symbol; + char* symbolName; + if (NULL == image) + { + image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); + } + /* prepend a '_' for the Unix C symbol mangling convention */ + symbolName = malloc(strlen((const char*)name) + 2); + strcpy(symbolName+1, (const char*)name); + symbolName[0] = '_'; + symbol = NULL; + /* if (NSIsSymbolNameDefined(symbolName)) + symbol = NSLookupAndBindSymbol(symbolName); */ + symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL; + free(symbolName); + if( symbol ) return NSAddressOfSymbol(symbol); +#ifdef GLEW_APPLE_GLX + return dlGetProcAddress( name ); // try next for glx symbols +#else + return NULL; +#endif +} +#endif /* MAC_OS_X_VERSION_10_3 */ +#endif /* __APPLE__ */ + +/* + * Define glewGetProcAddress. + */ +#if defined(_WIN32) +# define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name) +#else +# if defined(__APPLE__) +# define glewGetProcAddress(name) NSGLGetProcAddress(name) +# else +# if defined(__sgi) || defined(__sun) +# define glewGetProcAddress(name) dlGetProcAddress(name) +# else /* __linux */ +# define glewGetProcAddress(name) (*glXGetProcAddressARB)(name) +# endif +# endif +#endif + +/* + * Define GLboolean const cast. + */ +#define CONST_CAST(x) (*(GLboolean*)&x) + +/* + * GLEW, just like OpenGL or GLU, does not rely on the standard C library. + * These functions implement the functionality required in this file. + */ +static GLuint _glewStrLen (const GLubyte* s) +{ + GLuint i=0; + if (s == NULL) return 0; + while (s[i] != '\0') i++; + return i; +} + +static GLuint _glewStrCLen (const GLubyte* s, GLubyte c) +{ + GLuint i=0; + if (s == NULL) return 0; + while (s[i] != '\0' && s[i] != c) i++; + return (s[i] == '\0' || s[i] == c) ? i : 0; +} + +static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n) +{ + GLuint i=0; + if(a == NULL || b == NULL) + return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE; + while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++; + return i == n ? GL_TRUE : GL_FALSE; +} + +static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t')) + { + (*a)++; + (*na)--; + } + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if(i == nb) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if(i == nb) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t')) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +/* + * Search for name in the extensions string. Use of strstr() + * is not sufficient because extension names can be prefixes of + * other extension names. Could use strtok() but the constant + * string returned by glGetString might be in read-only memory. + */ +static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end) +{ + const GLubyte* p; + GLuint len = _glewStrLen((const GLubyte*)name); + p = start; + while (p < end) + { + GLuint n = _glewStrCLen(p, ' '); + if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; + p += n+1; + } + return GL_FALSE; +} + +#if !defined(_WIN32) || !defined(GLEW_MX) + +PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL; +PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL; +PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL; +PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL; + +PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL; +PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL; +PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL; +PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL; + +PFNGLBLENDCOLORPROC __glewBlendColor = NULL; +PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL; +PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL; +PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL; +PFNGLFOGCOORDDPROC __glewFogCoordd = NULL; +PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL; +PFNGLFOGCOORDFPROC __glewFogCoordf = NULL; +PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL; +PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL; +PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL; +PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL; +PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL; +PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL; +PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL; +PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL; +PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL; +PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL; +PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL; +PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL; +PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL; +PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL; +PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL; +PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL; +PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL; +PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL; +PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL; +PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL; +PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL; +PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL; +PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL; +PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL; +PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL; +PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL; +PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL; +PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL; +PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL; +PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL; +PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL; +PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL; +PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL; +PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL; +PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL; +PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL; + +PFNGLBEGINQUERYPROC __glewBeginQuery = NULL; +PFNGLBINDBUFFERPROC __glewBindBuffer = NULL; +PFNGLBUFFERDATAPROC __glewBufferData = NULL; +PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL; +PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL; +PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL; +PFNGLENDQUERYPROC __glewEndQuery = NULL; +PFNGLGENBUFFERSPROC __glewGenBuffers = NULL; +PFNGLGENQUERIESPROC __glewGenQueries = NULL; +PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL; +PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL; +PFNGLISBUFFERPROC __glewIsBuffer = NULL; +PFNGLISQUERYPROC __glewIsQuery = NULL; +PFNGLMAPBUFFERPROC __glewMapBuffer = NULL; +PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL; + +PFNGLATTACHSHADERPROC __glewAttachShader = NULL; +PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL; +PFNGLCOMPILESHADERPROC __glewCompileShader = NULL; +PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL; +PFNGLCREATESHADERPROC __glewCreateShader = NULL; +PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL; +PFNGLDELETESHADERPROC __glewDeleteShader = NULL; +PFNGLDETACHSHADERPROC __glewDetachShader = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL; +PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL; +PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL; +PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL; +PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL; +PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL; +PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL; +PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL; +PFNGLISPROGRAMPROC __glewIsProgram = NULL; +PFNGLISSHADERPROC __glewIsShader = NULL; +PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL; +PFNGLSHADERSOURCEPROC __glewShaderSource = NULL; +PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL; +PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL; +PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL; +PFNGLUNIFORM1FPROC __glewUniform1f = NULL; +PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL; +PFNGLUNIFORM1IPROC __glewUniform1i = NULL; +PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL; +PFNGLUNIFORM2FPROC __glewUniform2f = NULL; +PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL; +PFNGLUNIFORM2IPROC __glewUniform2i = NULL; +PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL; +PFNGLUNIFORM3FPROC __glewUniform3f = NULL; +PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL; +PFNGLUNIFORM3IPROC __glewUniform3i = NULL; +PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL; +PFNGLUNIFORM4FPROC __glewUniform4f = NULL; +PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL; +PFNGLUNIFORM4IPROC __glewUniform4i = NULL; +PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL; +PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL; +PFNGLUSEPROGRAMPROC __glewUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL; + +PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL; + +PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL; +PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL; +PFNGLCLAMPCOLORPROC __glewClampColor = NULL; +PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL; +PFNGLCOLORMASKIPROC __glewColorMaski = NULL; +PFNGLDISABLEIPROC __glewDisablei = NULL; +PFNGLENABLEIPROC __glewEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL; +PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL; +PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL; +PFNGLGETSTRINGIPROC __glewGetStringi = NULL; +PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL; +PFNGLISENABLEDIPROC __glewIsEnabledi = NULL; +PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL; +PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL; +PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL; +PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL; +PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL; + +PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL; +PFNGLTEXBUFFERPROC __glewTexBuffer = NULL; + +PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL; +PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL; + +PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL; + +PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL; +PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL; +PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL; +PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL; +PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL; + +PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL; + +PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL; +PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL; +PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL; +PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL; + +PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL; +PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL; +PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL; +PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL; + +PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL; +PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL; + +PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL; +PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL; +PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL; + +PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL; +PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL; +PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL; +PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL; +PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL; +PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL; +PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL; +PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL; +PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL; +PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL; +PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL; + +PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL; + +PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL; +PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL; + +PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL; +PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL; +PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL; +PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL; +PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL; + +PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL; +PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL; +PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL; +PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL; +PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL; +PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL; +PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL; +PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL; + +PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL; + +PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL; +PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL; +PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL; + +PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL; +PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL; + +PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL; +PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL; +PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL; +PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL; + +PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL; +PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL; +PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL; + +PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL; +PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL; +PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL; +PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL; +PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL; +PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL; +PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL; + +PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL; +PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL; +PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL; +PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL; +PFNGLSHADERBINARYPROC __glewShaderBinary = NULL; + +PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL; + +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL; +PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL; + +PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL; + +PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL; + +PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL; + +PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL; +PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL; +PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL; +PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL; + +PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL; + +PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL; +PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL; +PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL; +PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL; + +PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL; + +PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL; +PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL; + +PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL; +PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL; +PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL; +PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL; +PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL; +PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL; +PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL; +PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL; +PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL; +PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL; + +PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL; +PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL; +PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL; + +PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL; +PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL; +PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL; + +PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL; +PFNGLPROGRAMUNIFORM1DEXTPROC __glewProgramUniform1dEXT = NULL; +PFNGLPROGRAMUNIFORM1DVEXTPROC __glewProgramUniform1dvEXT = NULL; +PFNGLPROGRAMUNIFORM2DEXTPROC __glewProgramUniform2dEXT = NULL; +PFNGLPROGRAMUNIFORM2DVEXTPROC __glewProgramUniform2dvEXT = NULL; +PFNGLPROGRAMUNIFORM3DEXTPROC __glewProgramUniform3dEXT = NULL; +PFNGLPROGRAMUNIFORM3DVEXTPROC __glewProgramUniform3dvEXT = NULL; +PFNGLPROGRAMUNIFORM4DEXTPROC __glewProgramUniform4dEXT = NULL; +PFNGLPROGRAMUNIFORM4DVEXTPROC __glewProgramUniform4dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC __glewProgramUniformMatrix2dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC __glewProgramUniformMatrix2x3dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC __glewProgramUniformMatrix2x4dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC __glewProgramUniformMatrix3dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC __glewProgramUniformMatrix3x2dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC __glewProgramUniformMatrix3x4dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC __glewProgramUniformMatrix4dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC __glewProgramUniformMatrix4x2dvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC __glewProgramUniformMatrix4x3dvEXT = NULL; +PFNGLUNIFORM1DPROC __glewUniform1d = NULL; +PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL; +PFNGLUNIFORM2DPROC __glewUniform2d = NULL; +PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL; +PFNGLUNIFORM3DPROC __glewUniform3d = NULL; +PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL; +PFNGLUNIFORM4DPROC __glewUniform4d = NULL; +PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL; +PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL; +PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL; +PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL; +PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL; +PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL; +PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL; +PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL; +PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL; +PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL; + +PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL; +PFNGLCOLORTABLEPROC __glewColorTable = NULL; +PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL; +PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL; +PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL; +PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL; +PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL; +PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL; +PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL; +PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL; +PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL; +PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL; +PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL; +PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL; +PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL; +PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL; +PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL; +PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL; +PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL; +PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL; +PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL; +PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL; +PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL; +PFNGLGETMINMAXPROC __glewGetMinmax = NULL; +PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL; +PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL; +PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL; +PFNGLHISTOGRAMPROC __glewHistogram = NULL; +PFNGLMINMAXPROC __glewMinmax = NULL; +PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL; +PFNGLRESETMINMAXPROC __glewResetMinmax = NULL; +PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL; + +PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL; +PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL; +PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL; + +PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL; + +PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL; +PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL; + +PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL; +PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL; +PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL; +PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL; +PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL; + +PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL; + +PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL; +PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL; +PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL; +PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL; +PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL; +PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL; +PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL; +PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL; +PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL; +PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL; +PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL; +PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL; +PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL; +PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL; +PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL; +PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL; +PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL; +PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL; +PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL; +PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL; +PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL; +PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL; +PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL; +PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL; +PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL; +PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL; +PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL; +PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL; +PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL; +PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL; +PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL; +PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL; +PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL; +PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL; + +PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL; +PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL; +PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL; +PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL; +PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL; +PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL; +PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL; +PFNGLISQUERYARBPROC __glewIsQueryARB = NULL; + +PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL; +PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL; + +PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL; + +PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL; +PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL; +PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL; +PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL; +PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL; +PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL; +PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL; +PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL; +PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL; +PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL; +PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL; +PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL; +PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL; +PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL; +PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL; +PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL; +PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL; +PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL; +PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL; +PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL; + +PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL; + +PFNGLBINDSAMPLERPROC __glewBindSampler = NULL; +PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL; +PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL; +PFNGLISSAMPLERPROC __glewIsSampler = NULL; +PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL; + +PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL; +PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL; +PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL; +PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL; +PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL; +PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL; +PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL; +PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL; +PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL; +PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL; +PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL; +PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL; +PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL; +PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL; +PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL; +PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL; +PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL; +PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL; +PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL; +PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL; +PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL; +PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL; +PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL; +PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL; +PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL; +PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL; +PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL; +PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL; +PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL; +PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL; +PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL; +PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL; +PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL; +PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL; +PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL; +PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL; +PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL; +PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL; +PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL; +PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL; +PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL; +PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL; + +PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL; + +PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL; +PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL; + +PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL; +PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL; +PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL; +PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL; +PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL; +PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL; +PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL; +PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL; +PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL; +PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL; +PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL; +PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL; +PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL; +PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL; +PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL; +PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL; +PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL; +PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL; +PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL; +PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL; +PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL; +PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL; +PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL; +PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL; +PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL; +PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL; +PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL; +PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL; +PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL; +PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL; +PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL; +PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL; +PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL; +PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL; +PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL; +PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL; +PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL; +PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL; +PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL; + +PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL; +PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL; +PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL; +PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL; +PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL; +PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL; +PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL; +PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL; + +PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL; +PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL; +PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL; +PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL; +PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL; +PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL; + +PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL; +PFNGLDELETESYNCPROC __glewDeleteSync = NULL; +PFNGLFENCESYNCPROC __glewFenceSync = NULL; +PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL; +PFNGLGETSYNCIVPROC __glewGetSynciv = NULL; +PFNGLISSYNCPROC __glewIsSync = NULL; +PFNGLWAITSYNCPROC __glewWaitSync = NULL; + +PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL; +PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL; + +PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL; + +PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL; + +PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL; +PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL; + +PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL; +PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL; +PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL; +PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL; +PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL; +PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL; + +PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL; +PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL; + +PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL; +PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL; +PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL; +PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL; +PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL; +PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL; +PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL; + +PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL; +PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL; +PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL; +PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL; + +PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL; +PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL; + +PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL; +PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL; +PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL; +PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL; + +PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL; +PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL; + +PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL; +PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL; +PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL; +PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL; + +PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL; +PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL; +PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL; +PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL; +PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL; +PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL; +PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL; +PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL; +PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL; +PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL; + +PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL; +PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL; +PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL; +PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL; +PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL; +PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL; +PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL; +PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL; +PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL; +PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL; + +PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL; +PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL; +PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL; +PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL; +PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL; +PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL; +PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL; +PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL; +PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL; +PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL; +PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL; + +PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL; +PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL; +PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL; +PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL; +PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL; +PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL; +PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL; +PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL; +PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL; +PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL; +PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL; +PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL; +PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL; +PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL; +PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL; +PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL; +PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL; +PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL; +PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL; +PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL; +PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL; +PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL; +PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL; +PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL; +PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL; +PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL; +PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL; +PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL; +PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL; +PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL; +PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL; +PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL; +PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL; +PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL; +PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL; +PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL; +PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL; +PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL; +PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL; +PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL; +PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL; +PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL; +PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL; +PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL; +PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL; +PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL; +PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL; +PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL; +PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL; +PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL; +PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL; +PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL; +PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL; +PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL; +PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL; +PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL; +PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL; + +PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL; +PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL; +PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL; + +PFNGLCOLORP3UIPROC __glewColorP3ui = NULL; +PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL; +PFNGLCOLORP4UIPROC __glewColorP4ui = NULL; +PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL; +PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL; +PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL; +PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL; +PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL; +PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL; + +PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL; +PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL; +PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL; +PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL; +PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL; +PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL; +PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL; +PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL; +PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL; +PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL; + +PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL; +PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL; +PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL; +PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL; +PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL; +PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL; +PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL; +PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL; +PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL; +PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL; +PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL; +PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL; +PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL; +PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL; +PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL; +PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL; + +PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL; + +PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL; +PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL; +PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL; + +PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL; +PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL; +PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL; +PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL; + +PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL; +PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL; +PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL; +PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL; +PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL; +PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL; +PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL; +PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL; +PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL; +PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL; +PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL; +PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL; +PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL; +PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL; + +PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL; +PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL; + +PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL; +PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL; + +PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL; +PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL; + +PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL; +PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL; +PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL; +PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL; +PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL; +PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL; +PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL; +PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL; +PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL; +PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL; +PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL; +PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL; + +PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL; +PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL; +PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL; + +PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL; +PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL; +PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL; +PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL; +PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL; +PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL; +PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL; +PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL; +PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL; +PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL; +PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL; +PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL; +PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL; +PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL; +PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL; +PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL; +PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL; +PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL; +PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL; +PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL; +PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL; +PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL; +PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL; +PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL; +PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL; +PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL; +PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL; +PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL; +PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL; +PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL; +PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL; +PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL; +PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL; +PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL; +PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL; +PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL; +PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL; + +PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL; +PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL; +PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL; + +PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL; + +PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL; + +PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL; + +PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL; + +PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL; +PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL; + +PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL; +PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL; + +PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL; +PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL; +PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL; +PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL; +PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL; +PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL; +PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL; +PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL; +PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL; +PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL; +PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL; +PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL; +PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL; + +PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL; +PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL; + +PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL; +PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL; + +PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL; +PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL; + +PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL; + +PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL; +PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL; +PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL; +PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL; +PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL; +PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL; +PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL; +PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL; +PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL; +PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL; +PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL; +PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL; +PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL; +PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL; +PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL; +PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL; +PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL; +PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL; +PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL; +PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL; +PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL; +PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL; +PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL; +PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL; +PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL; +PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL; +PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL; +PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL; +PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL; +PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL; +PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL; +PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL; +PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL; +PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL; +PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL; +PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL; +PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL; +PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL; +PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL; +PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL; +PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL; +PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL; +PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL; +PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL; +PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL; +PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL; +PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL; +PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL; +PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL; +PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL; +PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL; +PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL; +PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL; +PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL; +PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL; +PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL; +PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL; +PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL; +PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL; +PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL; +PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL; +PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL; +PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL; +PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL; +PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL; +PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL; +PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL; +PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL; +PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL; +PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL; +PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL; +PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL; +PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL; +PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL; +PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL; +PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL; +PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL; +PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL; +PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL; +PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL; +PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL; +PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL; +PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL; +PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL; +PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL; +PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL; +PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL; +PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL; +PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL; +PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL; +PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL; +PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL; +PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL; +PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL; +PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL; +PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL; +PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL; +PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL; +PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL; +PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL; +PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL; +PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL; +PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL; +PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL; +PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL; +PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL; +PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL; +PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL; +PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL; +PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL; +PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL; +PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL; +PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL; +PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL; +PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL; +PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL; +PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL; +PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL; +PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL; +PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL; +PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL; +PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL; +PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL; +PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL; +PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL; +PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL; +PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL; +PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL; +PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL; +PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL; +PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL; +PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL; +PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL; +PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL; +PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL; +PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL; +PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL; +PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL; +PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL; +PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL; +PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL; +PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL; +PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL; +PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL; +PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL; +PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL; +PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL; +PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL; +PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL; +PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL; +PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL; +PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL; +PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL; +PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL; +PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL; +PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL; +PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL; +PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL; +PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL; +PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL; +PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL; +PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL; + +PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL; +PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL; +PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL; +PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL; +PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL; +PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL; + +PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL; +PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL; + +PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL; + +PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL; +PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL; +PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL; +PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL; +PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL; + +PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL; +PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL; +PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL; +PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL; +PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL; +PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL; +PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL; +PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL; +PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL; +PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL; +PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL; +PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL; +PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL; +PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL; +PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL; +PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL; +PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL; +PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL; + +PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL; + +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL; + +PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL; +PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL; +PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL; +PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL; +PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL; +PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL; +PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL; +PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL; +PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL; +PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL; +PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL; + +PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL; +PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL; +PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL; + +PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL; +PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL; + +PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL; +PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL; +PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL; +PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL; +PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL; +PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL; +PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL; +PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL; +PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL; +PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL; +PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL; +PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL; +PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL; +PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL; +PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL; +PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL; +PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL; +PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL; +PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL; +PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL; +PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL; +PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL; +PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL; +PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL; +PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL; +PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL; +PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL; +PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL; +PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL; +PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL; +PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL; +PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL; +PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL; +PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL; + +PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL; +PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL; +PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL; +PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL; +PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL; +PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL; +PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL; +PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL; +PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL; +PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL; + +PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL; + +PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL; + +PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL; +PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL; +PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL; + +PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL; +PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL; + +PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL; +PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL; + +PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL; +PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL; +PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL; +PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL; + +PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL; +PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL; + +PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL; +PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL; + +PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL; + +PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL; + +PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL; +PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL; + +PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL; +PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL; +PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL; +PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL; +PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL; +PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL; +PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL; +PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL; +PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL; +PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL; +PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL; +PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL; +PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL; +PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL; +PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL; +PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL; +PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL; + +PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL; +PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL; +PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL; + +PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL; +PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL; + +PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL; + +PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL; +PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL; +PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL; + +PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL; + +PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL; + +PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL; + +PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL; +PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL; +PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL; +PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL; +PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL; +PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL; + +PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL; +PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL; +PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL; +PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL; +PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL; +PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL; + +PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL; + +PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL; +PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL; + +PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL; +PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL; +PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL; +PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL; +PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL; + +PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL; +PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL; +PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL; +PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL; +PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL; +PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL; +PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL; +PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL; + +PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL; +PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL; +PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL; +PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL; +PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL; +PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL; +PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL; +PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL; +PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL; +PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL; +PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL; + +PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL; +PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL; +PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL; +PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL; +PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL; +PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL; +PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL; +PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL; +PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL; +PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL; +PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL; +PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL; +PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL; +PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL; +PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL; +PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL; +PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL; +PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL; +PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL; +PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL; +PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL; +PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL; +PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL; +PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL; +PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL; +PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL; +PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL; +PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL; +PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL; +PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL; +PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL; +PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL; +PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL; +PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL; +PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL; +PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL; +PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL; +PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL; +PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL; +PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL; +PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL; +PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL; + +PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL; +PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL; +PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL; + +PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL; + +PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL; + +PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL; + +PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL; +PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL; + +PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL; +PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL; + +PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL; +PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL; +PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL; +PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL; +PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL; +PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL; +PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL; +PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL; + +PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL; +PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL; +PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL; +PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL; + +PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL; +PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL; + +PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL; +PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL; +PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL; +PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL; +PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL; + +PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL; + +PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL; +PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL; +PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL; +PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL; +PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL; +PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL; +PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL; +PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL; +PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL; +PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL; +PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL; +PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL; +PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL; +PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL; +PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL; +PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL; +PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL; +PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL; +PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL; +PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL; +PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL; +PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL; +PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL; +PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL; + +PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL; +PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL; + +PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL; + +PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL; +PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL; +PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL; + +PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL; +PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL; +PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL; +PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL; +PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL; +PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL; +PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL; +PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL; +PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL; + +PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL; +PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL; +PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL; + +PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL; +PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL; +PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL; +PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL; +PFNGLISFENCENVPROC __glewIsFenceNV = NULL; +PFNGLSETFENCENVPROC __glewSetFenceNV = NULL; +PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL; + +PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL; +PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL; + +PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL; + +PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL; + +PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL; +PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL; +PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL; +PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL; +PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL; +PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL; + +PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL; +PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL; +PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL; +PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL; +PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL; +PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL; +PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL; +PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL; +PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL; +PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL; +PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL; +PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL; +PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL; +PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL; +PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL; +PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL; +PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL; +PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL; +PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL; +PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL; +PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL; +PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL; +PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL; +PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL; +PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL; +PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL; +PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL; +PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL; +PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL; +PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL; +PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL; +PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL; +PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL; +PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL; + +PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL; +PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL; +PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL; +PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL; +PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL; +PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL; +PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL; +PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL; +PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL; +PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL; +PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL; +PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL; +PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL; +PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL; +PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL; +PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL; +PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL; +PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL; +PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL; +PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL; +PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL; +PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL; +PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL; +PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL; +PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL; +PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL; +PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL; +PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL; +PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL; +PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL; +PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL; +PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL; +PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL; +PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL; +PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL; +PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL; +PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL; +PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL; +PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL; +PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL; +PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL; +PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL; +PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL; +PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL; +PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL; +PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL; + +PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL; +PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL; +PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL; +PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL; +PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL; +PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL; +PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL; + +PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL; +PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL; +PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL; + +PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL; +PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL; +PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL; +PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL; +PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL; +PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL; +PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL; +PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL; +PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL; +PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL; +PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL; +PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL; +PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL; +PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL; +PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL; +PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL; +PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL; +PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL; +PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL; +PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL; +PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL; +PFNGLISPATHNVPROC __glewIsPathNV = NULL; +PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL; +PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL; +PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL; +PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL; +PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL; +PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL; +PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL; +PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL; +PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL; +PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL; +PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL; +PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL; +PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL; +PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL; +PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL; +PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL; +PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL; +PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL; +PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL; +PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL; +PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL; +PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL; +PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL; +PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL; +PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL; +PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL; +PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL; + +PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL; +PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL; + +PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL; +PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL; + +PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL; +PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL; +PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL; +PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL; +PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL; +PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL; + +PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL; +PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL; + +PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL; +PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL; +PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL; +PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL; +PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL; +PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL; +PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL; +PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL; +PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL; +PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL; +PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL; +PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL; +PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL; + +PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL; +PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL; + +PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL; +PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL; +PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL; +PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL; +PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL; +PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL; +PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL; +PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL; +PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL; +PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL; +PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL; +PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL; +PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL; + +PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL; + +PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL; +PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL; +PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL; +PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL; +PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL; +PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL; + +PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL; +PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL; +PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL; +PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL; +PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL; +PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL; +PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL; +PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL; +PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL; + +PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL; +PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL; +PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL; +PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL; +PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL; +PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL; +PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL; + +PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL; +PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL; +PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL; +PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL; +PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL; +PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL; +PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL; +PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL; +PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL; +PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL; + +PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL; +PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL; + +PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL; +PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL; +PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL; +PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL; +PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL; +PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL; +PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL; +PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL; +PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL; +PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL; +PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL; +PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL; +PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL; +PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL; +PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL; +PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL; +PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL; +PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL; +PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL; + +PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL; +PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL; +PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL; +PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL; +PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL; +PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL; +PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL; +PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL; +PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL; +PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL; +PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL; +PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL; + +PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL; +PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL; +PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL; +PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL; +PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL; +PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL; +PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL; +PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL; +PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL; +PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL; +PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL; +PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL; +PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL; +PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL; +PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL; +PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL; +PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL; +PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL; +PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL; +PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL; +PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL; +PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL; +PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL; +PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL; +PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL; +PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL; +PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL; +PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL; +PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL; +PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL; +PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL; +PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL; +PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL; +PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL; +PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL; +PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL; +PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL; +PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL; +PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL; +PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL; +PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL; +PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL; +PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL; +PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL; +PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL; +PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL; +PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL; +PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL; +PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL; +PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL; +PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL; +PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL; +PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL; +PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL; +PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL; +PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL; +PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL; +PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL; +PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL; +PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL; +PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL; +PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL; +PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL; +PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL; + +PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL; +PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL; +PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL; +PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL; +PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL; +PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL; +PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL; +PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL; +PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL; +PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL; +PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL; +PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL; + +PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL; +PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL; +PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL; +PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL; +PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL; +PFNGLORTHOFOESPROC __glewOrthofOES = NULL; + +PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL; +PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL; + +PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL; +PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL; + +PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL; +PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL; + +PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL; +PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL; + +PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL; +PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL; + +PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL; +PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL; + +PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL; +PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL; +PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL; +PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL; +PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL; +PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL; + +PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL; + +PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL; + +PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL; +PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL; +PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL; +PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL; +PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL; +PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL; +PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL; +PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL; +PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL; +PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL; +PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL; +PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL; +PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL; + +PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL; + +PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL; + +PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL; + +PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL; +PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL; +PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL; +PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL; + +PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL; + +PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL; +PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL; +PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL; +PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL; +PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL; +PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL; +PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL; + +PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL; + +PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL; +PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL; +PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL; +PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL; +PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL; +PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL; +PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL; +PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL; + +PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL; + +PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL; +PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL; +PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL; +PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL; +PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL; +PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL; +PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL; + +PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL; +PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL; +PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL; +PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL; +PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL; +PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL; +PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL; +PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL; +PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL; +PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL; +PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL; +PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL; +PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL; + +PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL; + +#endif /* !WIN32 || !GLEW_MX */ + +#if !defined(GLEW_MX) + +GLboolean __GLEW_VERSION_1_1 = GL_FALSE; +GLboolean __GLEW_VERSION_1_2 = GL_FALSE; +GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE; +GLboolean __GLEW_VERSION_1_3 = GL_FALSE; +GLboolean __GLEW_VERSION_1_4 = GL_FALSE; +GLboolean __GLEW_VERSION_1_5 = GL_FALSE; +GLboolean __GLEW_VERSION_2_0 = GL_FALSE; +GLboolean __GLEW_VERSION_2_1 = GL_FALSE; +GLboolean __GLEW_VERSION_3_0 = GL_FALSE; +GLboolean __GLEW_VERSION_3_1 = GL_FALSE; +GLboolean __GLEW_VERSION_3_2 = GL_FALSE; +GLboolean __GLEW_VERSION_3_3 = GL_FALSE; +GLboolean __GLEW_VERSION_4_0 = GL_FALSE; +GLboolean __GLEW_VERSION_4_1 = GL_FALSE; +GLboolean __GLEW_VERSION_4_2 = GL_FALSE; +GLboolean __GLEW_3DFX_multisample = GL_FALSE; +GLboolean __GLEW_3DFX_tbuffer = GL_FALSE; +GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE; +GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE; +GLboolean __GLEW_AMD_conservative_depth = GL_FALSE; +GLboolean __GLEW_AMD_debug_output = GL_FALSE; +GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE; +GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE; +GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE; +GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE; +GLboolean __GLEW_AMD_performance_monitor = GL_FALSE; +GLboolean __GLEW_AMD_sample_positions = GL_FALSE; +GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE; +GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE; +GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE; +GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE; +GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE; +GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE; +GLboolean __GLEW_APPLE_client_storage = GL_FALSE; +GLboolean __GLEW_APPLE_element_array = GL_FALSE; +GLboolean __GLEW_APPLE_fence = GL_FALSE; +GLboolean __GLEW_APPLE_float_pixels = GL_FALSE; +GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE; +GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE; +GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE; +GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE; +GLboolean __GLEW_APPLE_row_bytes = GL_FALSE; +GLboolean __GLEW_APPLE_specular_vector = GL_FALSE; +GLboolean __GLEW_APPLE_texture_range = GL_FALSE; +GLboolean __GLEW_APPLE_transform_hint = GL_FALSE; +GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE; +GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE; +GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE; +GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE; +GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE; +GLboolean __GLEW_ARB_base_instance = GL_FALSE; +GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE; +GLboolean __GLEW_ARB_cl_event = GL_FALSE; +GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE; +GLboolean __GLEW_ARB_compatibility = GL_FALSE; +GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE; +GLboolean __GLEW_ARB_conservative_depth = GL_FALSE; +GLboolean __GLEW_ARB_copy_buffer = GL_FALSE; +GLboolean __GLEW_ARB_debug_output = GL_FALSE; +GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE; +GLboolean __GLEW_ARB_depth_clamp = GL_FALSE; +GLboolean __GLEW_ARB_depth_texture = GL_FALSE; +GLboolean __GLEW_ARB_draw_buffers = GL_FALSE; +GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE; +GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE; +GLboolean __GLEW_ARB_draw_indirect = GL_FALSE; +GLboolean __GLEW_ARB_draw_instanced = GL_FALSE; +GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE; +GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE; +GLboolean __GLEW_ARB_fragment_program = GL_FALSE; +GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE; +GLboolean __GLEW_ARB_fragment_shader = GL_FALSE; +GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE; +GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_ARB_get_program_binary = GL_FALSE; +GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE; +GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE; +GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE; +GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE; +GLboolean __GLEW_ARB_imaging = GL_FALSE; +GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE; +GLboolean __GLEW_ARB_internalformat_query = GL_FALSE; +GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE; +GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE; +GLboolean __GLEW_ARB_matrix_palette = GL_FALSE; +GLboolean __GLEW_ARB_multisample = GL_FALSE; +GLboolean __GLEW_ARB_multitexture = GL_FALSE; +GLboolean __GLEW_ARB_occlusion_query = GL_FALSE; +GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE; +GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_point_parameters = GL_FALSE; +GLboolean __GLEW_ARB_point_sprite = GL_FALSE; +GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE; +GLboolean __GLEW_ARB_robustness = GL_FALSE; +GLboolean __GLEW_ARB_sample_shading = GL_FALSE; +GLboolean __GLEW_ARB_sampler_objects = GL_FALSE; +GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE; +GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE; +GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE; +GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE; +GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE; +GLboolean __GLEW_ARB_shader_objects = GL_FALSE; +GLboolean __GLEW_ARB_shader_precision = GL_FALSE; +GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE; +GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE; +GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE; +GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE; +GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE; +GLboolean __GLEW_ARB_shading_language_include = GL_FALSE; +GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE; +GLboolean __GLEW_ARB_shadow = GL_FALSE; +GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE; +GLboolean __GLEW_ARB_sync = GL_FALSE; +GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE; +GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE; +GLboolean __GLEW_ARB_texture_compression = GL_FALSE; +GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE; +GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE; +GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE; +GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_add = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE; +GLboolean __GLEW_ARB_texture_float = GL_FALSE; +GLboolean __GLEW_ARB_texture_gather = GL_FALSE; +GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE; +GLboolean __GLEW_ARB_texture_multisample = GL_FALSE; +GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE; +GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE; +GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE; +GLboolean __GLEW_ARB_texture_rg = GL_FALSE; +GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE; +GLboolean __GLEW_ARB_texture_storage = GL_FALSE; +GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE; +GLboolean __GLEW_ARB_timer_query = GL_FALSE; +GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE; +GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE; +GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE; +GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE; +GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE; +GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE; +GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE; +GLboolean __GLEW_ARB_vertex_blend = GL_FALSE; +GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_vertex_program = GL_FALSE; +GLboolean __GLEW_ARB_vertex_shader = GL_FALSE; +GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE; +GLboolean __GLEW_ARB_viewport_array = GL_FALSE; +GLboolean __GLEW_ARB_window_pos = GL_FALSE; +GLboolean __GLEW_ATIX_point_sprites = GL_FALSE; +GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE; +GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE; +GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE; +GLboolean __GLEW_ATI_draw_buffers = GL_FALSE; +GLboolean __GLEW_ATI_element_array = GL_FALSE; +GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE; +GLboolean __GLEW_ATI_fragment_shader = GL_FALSE; +GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE; +GLboolean __GLEW_ATI_meminfo = GL_FALSE; +GLboolean __GLEW_ATI_pn_triangles = GL_FALSE; +GLboolean __GLEW_ATI_separate_stencil = GL_FALSE; +GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE; +GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE; +GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE; +GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE; +GLboolean __GLEW_ATI_texture_float = GL_FALSE; +GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE; +GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE; +GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE; +GLboolean __GLEW_ATI_vertex_streams = GL_FALSE; +GLboolean __GLEW_EXT_422_pixels = GL_FALSE; +GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; +GLboolean __GLEW_EXT_abgr = GL_FALSE; +GLboolean __GLEW_EXT_bgra = GL_FALSE; +GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE; +GLboolean __GLEW_EXT_blend_color = GL_FALSE; +GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE; +GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE; +GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE; +GLboolean __GLEW_EXT_blend_minmax = GL_FALSE; +GLboolean __GLEW_EXT_blend_subtract = GL_FALSE; +GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE; +GLboolean __GLEW_EXT_cmyka = GL_FALSE; +GLboolean __GLEW_EXT_color_subtable = GL_FALSE; +GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE; +GLboolean __GLEW_EXT_convolution = GL_FALSE; +GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE; +GLboolean __GLEW_EXT_copy_texture = GL_FALSE; +GLboolean __GLEW_EXT_cull_vertex = GL_FALSE; +GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE; +GLboolean __GLEW_EXT_direct_state_access = GL_FALSE; +GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE; +GLboolean __GLEW_EXT_draw_instanced = GL_FALSE; +GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE; +GLboolean __GLEW_EXT_fog_coord = GL_FALSE; +GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE; +GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE; +GLboolean __GLEW_EXT_histogram = GL_FALSE; +GLboolean __GLEW_EXT_index_array_formats = GL_FALSE; +GLboolean __GLEW_EXT_index_func = GL_FALSE; +GLboolean __GLEW_EXT_index_material = GL_FALSE; +GLboolean __GLEW_EXT_index_texture = GL_FALSE; +GLboolean __GLEW_EXT_light_texture = GL_FALSE; +GLboolean __GLEW_EXT_misc_attribute = GL_FALSE; +GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE; +GLboolean __GLEW_EXT_multisample = GL_FALSE; +GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_EXT_packed_float = GL_FALSE; +GLboolean __GLEW_EXT_packed_pixels = GL_FALSE; +GLboolean __GLEW_EXT_paletted_texture = GL_FALSE; +GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE; +GLboolean __GLEW_EXT_pixel_transform = GL_FALSE; +GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE; +GLboolean __GLEW_EXT_point_parameters = GL_FALSE; +GLboolean __GLEW_EXT_polygon_offset = GL_FALSE; +GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE; +GLboolean __GLEW_EXT_rescale_normal = GL_FALSE; +GLboolean __GLEW_EXT_scene_marker = GL_FALSE; +GLboolean __GLEW_EXT_secondary_color = GL_FALSE; +GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE; +GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE; +GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE; +GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE; +GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE; +GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE; +GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE; +GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE; +GLboolean __GLEW_EXT_subtexture = GL_FALSE; +GLboolean __GLEW_EXT_texture = GL_FALSE; +GLboolean __GLEW_EXT_texture3D = GL_FALSE; +GLboolean __GLEW_EXT_texture_array = GL_FALSE; +GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE; +GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE; +GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_env = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_add = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE; +GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE; +GLboolean __GLEW_EXT_texture_integer = GL_FALSE; +GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE; +GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_object = GL_FALSE; +GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE; +GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE; +GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE; +GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE; +GLboolean __GLEW_EXT_texture_snorm = GL_FALSE; +GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE; +GLboolean __GLEW_EXT_timer_query = GL_FALSE; +GLboolean __GLEW_EXT_transform_feedback = GL_FALSE; +GLboolean __GLEW_EXT_vertex_array = GL_FALSE; +GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE; +GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE; +GLboolean __GLEW_EXT_vertex_shader = GL_FALSE; +GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE; +GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE; +GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE; +GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE; +GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE; +GLboolean __GLEW_HP_image_transform = GL_FALSE; +GLboolean __GLEW_HP_occlusion_test = GL_FALSE; +GLboolean __GLEW_HP_texture_lighting = GL_FALSE; +GLboolean __GLEW_IBM_cull_vertex = GL_FALSE; +GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE; +GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE; +GLboolean __GLEW_IBM_static_data = GL_FALSE; +GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE; +GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE; +GLboolean __GLEW_INGR_color_clamp = GL_FALSE; +GLboolean __GLEW_INGR_interlace_read = GL_FALSE; +GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE; +GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE; +GLboolean __GLEW_KTX_buffer_region = GL_FALSE; +GLboolean __GLEW_MESAX_texture_stack = GL_FALSE; +GLboolean __GLEW_MESA_pack_invert = GL_FALSE; +GLboolean __GLEW_MESA_resize_buffers = GL_FALSE; +GLboolean __GLEW_MESA_window_pos = GL_FALSE; +GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE; +GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE; +GLboolean __GLEW_NV_blend_square = GL_FALSE; +GLboolean __GLEW_NV_conditional_render = GL_FALSE; +GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE; +GLboolean __GLEW_NV_copy_image = GL_FALSE; +GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE; +GLboolean __GLEW_NV_depth_clamp = GL_FALSE; +GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE; +GLboolean __GLEW_NV_evaluators = GL_FALSE; +GLboolean __GLEW_NV_explicit_multisample = GL_FALSE; +GLboolean __GLEW_NV_fence = GL_FALSE; +GLboolean __GLEW_NV_float_buffer = GL_FALSE; +GLboolean __GLEW_NV_fog_distance = GL_FALSE; +GLboolean __GLEW_NV_fragment_program = GL_FALSE; +GLboolean __GLEW_NV_fragment_program2 = GL_FALSE; +GLboolean __GLEW_NV_fragment_program4 = GL_FALSE; +GLboolean __GLEW_NV_fragment_program_option = GL_FALSE; +GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE; +GLboolean __GLEW_NV_geometry_program4 = GL_FALSE; +GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_NV_gpu_program4 = GL_FALSE; +GLboolean __GLEW_NV_gpu_program5 = GL_FALSE; +GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE; +GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE; +GLboolean __GLEW_NV_half_float = GL_FALSE; +GLboolean __GLEW_NV_light_max_exponent = GL_FALSE; +GLboolean __GLEW_NV_multisample_coverage = GL_FALSE; +GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; +GLboolean __GLEW_NV_occlusion_query = GL_FALSE; +GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE; +GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE; +GLboolean __GLEW_NV_path_rendering = GL_FALSE; +GLboolean __GLEW_NV_pixel_data_range = GL_FALSE; +GLboolean __GLEW_NV_point_sprite = GL_FALSE; +GLboolean __GLEW_NV_present_video = GL_FALSE; +GLboolean __GLEW_NV_primitive_restart = GL_FALSE; +GLboolean __GLEW_NV_register_combiners = GL_FALSE; +GLboolean __GLEW_NV_register_combiners2 = GL_FALSE; +GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE; +GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE; +GLboolean __GLEW_NV_texgen_emboss = GL_FALSE; +GLboolean __GLEW_NV_texgen_reflection = GL_FALSE; +GLboolean __GLEW_NV_texture_barrier = GL_FALSE; +GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE; +GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE; +GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE; +GLboolean __GLEW_NV_texture_multisample = GL_FALSE; +GLboolean __GLEW_NV_texture_rectangle = GL_FALSE; +GLboolean __GLEW_NV_texture_shader = GL_FALSE; +GLboolean __GLEW_NV_texture_shader2 = GL_FALSE; +GLboolean __GLEW_NV_texture_shader3 = GL_FALSE; +GLboolean __GLEW_NV_transform_feedback = GL_FALSE; +GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE; +GLboolean __GLEW_NV_vdpau_interop = GL_FALSE; +GLboolean __GLEW_NV_vertex_array_range = GL_FALSE; +GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE; +GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE; +GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE; +GLboolean __GLEW_NV_vertex_program = GL_FALSE; +GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program2 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE; +GLboolean __GLEW_NV_vertex_program3 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program4 = GL_FALSE; +GLboolean __GLEW_NV_video_capture = GL_FALSE; +GLboolean __GLEW_OES_byte_coordinates = GL_FALSE; +GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE; +GLboolean __GLEW_OES_read_format = GL_FALSE; +GLboolean __GLEW_OES_single_precision = GL_FALSE; +GLboolean __GLEW_OML_interlace = GL_FALSE; +GLboolean __GLEW_OML_resample = GL_FALSE; +GLboolean __GLEW_OML_subsample = GL_FALSE; +GLboolean __GLEW_PGI_misc_hints = GL_FALSE; +GLboolean __GLEW_PGI_vertex_hints = GL_FALSE; +GLboolean __GLEW_REND_screen_coordinates = GL_FALSE; +GLboolean __GLEW_S3_s3tc = GL_FALSE; +GLboolean __GLEW_SGIS_color_range = GL_FALSE; +GLboolean __GLEW_SGIS_detail_texture = GL_FALSE; +GLboolean __GLEW_SGIS_fog_function = GL_FALSE; +GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE; +GLboolean __GLEW_SGIS_multisample = GL_FALSE; +GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE; +GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE; +GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE; +GLboolean __GLEW_SGIS_texture4D = GL_FALSE; +GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE; +GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE; +GLboolean __GLEW_SGIS_texture_lod = GL_FALSE; +GLboolean __GLEW_SGIS_texture_select = GL_FALSE; +GLboolean __GLEW_SGIX_async = GL_FALSE; +GLboolean __GLEW_SGIX_async_histogram = GL_FALSE; +GLboolean __GLEW_SGIX_async_pixel = GL_FALSE; +GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE; +GLboolean __GLEW_SGIX_clipmap = GL_FALSE; +GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE; +GLboolean __GLEW_SGIX_depth_texture = GL_FALSE; +GLboolean __GLEW_SGIX_flush_raster = GL_FALSE; +GLboolean __GLEW_SGIX_fog_offset = GL_FALSE; +GLboolean __GLEW_SGIX_fog_texture = GL_FALSE; +GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE; +GLboolean __GLEW_SGIX_framezoom = GL_FALSE; +GLboolean __GLEW_SGIX_interlace = GL_FALSE; +GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE; +GLboolean __GLEW_SGIX_list_priority = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE; +GLboolean __GLEW_SGIX_reference_plane = GL_FALSE; +GLboolean __GLEW_SGIX_resample = GL_FALSE; +GLboolean __GLEW_SGIX_shadow = GL_FALSE; +GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE; +GLboolean __GLEW_SGIX_sprite = GL_FALSE; +GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE; +GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE; +GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE; +GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE; +GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE; +GLboolean __GLEW_SGIX_texture_range = GL_FALSE; +GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE; +GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE; +GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE; +GLboolean __GLEW_SGIX_ycrcb = GL_FALSE; +GLboolean __GLEW_SGI_color_matrix = GL_FALSE; +GLboolean __GLEW_SGI_color_table = GL_FALSE; +GLboolean __GLEW_SGI_texture_color_table = GL_FALSE; +GLboolean __GLEW_SUNX_constant_data = GL_FALSE; +GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE; +GLboolean __GLEW_SUN_global_alpha = GL_FALSE; +GLboolean __GLEW_SUN_mesh_array = GL_FALSE; +GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE; +GLboolean __GLEW_SUN_slice_accum = GL_FALSE; +GLboolean __GLEW_SUN_triangle_list = GL_FALSE; +GLboolean __GLEW_SUN_vertex = GL_FALSE; +GLboolean __GLEW_WIN_phong_shading = GL_FALSE; +GLboolean __GLEW_WIN_specular_fog = GL_FALSE; +GLboolean __GLEW_WIN_swap_hint = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef GL_VERSION_1_2 + +static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r; + r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r; + r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r; + r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_2 */ + +#ifdef GL_VERSION_1_2_1 + +#endif /* GL_VERSION_1_2_1 */ + +#ifdef GL_VERSION_1_3 + +static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r; + r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r; + r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r; + r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r; + r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r; + r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r; + r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r; + r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r; + r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r; + r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r; + r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r; + r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r; + r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r; + r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r; + r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r; + r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r; + r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r; + r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r; + r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r; + r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r; + r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r; + r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r; + r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r; + r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r; + r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r; + r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r; + r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r; + r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r; + r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r; + r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r; + r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r; + r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r; + r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r; + r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r; + r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r; + r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r; + r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r; + r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r; + r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r; + r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r; + r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r; + r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r; + r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r; + r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r; + r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r; + r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_3 */ + +#ifdef GL_VERSION_1_4 + +static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r; + r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; + r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r; + r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r; + r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r; + r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r; + r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r; + r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r; + r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r; + r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r; + r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r; + r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r; + r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r; + r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r; + r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r; + r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r; + r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r; + r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r; + r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r; + r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r; + r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r; + r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r; + r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r; + r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r; + r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r; + r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r; + r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r; + r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r; + r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r; + r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r; + r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r; + r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r; + r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r; + r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r; + r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r; + r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r; + r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r; + r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r; + r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r; + r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r; + r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r; + r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r; + r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r; + r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r; + r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r; + r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r; + r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_4 */ + +#ifdef GL_VERSION_1_5 + +static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r; + r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r; + r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r; + r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r; + r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r; + r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r; + r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r; + r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r; + r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r; + r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r; + r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r; + r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r; + r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r; + r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r; + r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r; + r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r; + r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r; + r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r; + r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_5 */ + +#ifdef GL_VERSION_2_0 + +static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r; + r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r; + r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r; + r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r; + r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r; + r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r; + r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r; + r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r; + r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r; + r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r; + r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r; + r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r; + r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r; + r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r; + r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r; + r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r; + r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r; + r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r; + r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r; + r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r; + r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r; + r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r; + r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r; + r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r; + r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r; + r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r; + r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r; + r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r; + r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r; + r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r; + r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r; + r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r; + r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r; + r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r; + r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r; + r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r; + r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r; + r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r; + r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r; + r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r; + r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r; + r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r; + r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r; + r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r; + r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r; + r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r; + r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r; + r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r; + r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r; + r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r; + r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r; + r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r; + r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r; + r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r; + r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r; + r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r; + r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r; + r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r; + r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r; + r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r; + r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r; + r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r; + r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r; + r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r; + r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r; + r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r; + r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r; + r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r; + r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r; + r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r; + r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r; + r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r; + r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r; + r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r; + r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r; + r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r; + r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r; + r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r; + r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r; + r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r; + r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r; + r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r; + r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r; + r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r; + r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r; + r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r; + r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r; + r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r; + r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r; + r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r; + r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r; + r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r; + r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_2_0 */ + +#ifdef GL_VERSION_2_1 + +static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r; + r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r; + r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r; + r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r; + r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r; + r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_2_1 */ + +#ifdef GL_VERSION_3_0 + +static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r; + r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r; + r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r; + r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r; + r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r; + r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r; + r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r; + r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r; + r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r; + r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r; + r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r; + r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r; + r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r; + r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r; + r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r; + r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r; + r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r; + r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r; + r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r; + r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r; + r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r; + r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r; + r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r; + r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r; + r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r; + r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r; + r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r; + r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r; + r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r; + r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r; + r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r; + r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r; + r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r; + r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r; + r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r; + r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r; + r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r; + r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r; + r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r; + r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r; + r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r; + r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r; + r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r; + r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r; + r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r; + r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r; + r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r; + r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r; + r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r; + r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r; + r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r; + r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r; + r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r; + r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r; + r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_3_0 */ + +#ifdef GL_VERSION_3_1 + +static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r; + r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r; + r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r; + r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_3_1 */ + +#ifdef GL_VERSION_3_2 + +static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r; + r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r; + r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_3_2 */ + +#ifdef GL_VERSION_3_3 + +static GLboolean _glewInit_GL_VERSION_3_3 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_3_3 */ + +#ifdef GL_VERSION_4_0 + +static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r; + r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r; + r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r; + r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r; + r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_4_0 */ + +#ifdef GL_VERSION_4_1 + +#endif /* GL_VERSION_4_1 */ + +#ifdef GL_VERSION_4_2 + +#endif /* GL_VERSION_4_2 */ + +#ifdef GL_3DFX_multisample + +#endif /* GL_3DFX_multisample */ + +#ifdef GL_3DFX_tbuffer + +static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r; + + return r; +} + +#endif /* GL_3DFX_tbuffer */ + +#ifdef GL_3DFX_texture_compression_FXT1 + +#endif /* GL_3DFX_texture_compression_FXT1 */ + +#ifdef GL_AMD_blend_minmax_factor + +#endif /* GL_AMD_blend_minmax_factor */ + +#ifdef GL_AMD_conservative_depth + +#endif /* GL_AMD_conservative_depth */ + +#ifdef GL_AMD_debug_output + +static GLboolean _glewInit_GL_AMD_debug_output (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r; + r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r; + r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r; + r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_debug_output */ + +#ifdef GL_AMD_depth_clamp_separate + +#endif /* GL_AMD_depth_clamp_separate */ + +#ifdef GL_AMD_draw_buffers_blend + +static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r; + r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r; + r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r; + r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_draw_buffers_blend */ + +#ifdef GL_AMD_multi_draw_indirect + +static GLboolean _glewInit_GL_AMD_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r; + r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_multi_draw_indirect */ + +#ifdef GL_AMD_name_gen_delete + +static GLboolean _glewInit_GL_AMD_name_gen_delete (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r; + r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r; + r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_name_gen_delete */ + +#ifdef GL_AMD_performance_monitor + +static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r; + r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r; + r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r; + r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r; + r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r; + r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r; + r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r; + r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r; + r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r; + r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r; + r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_performance_monitor */ + +#ifdef GL_AMD_sample_positions + +static GLboolean _glewInit_GL_AMD_sample_positions (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_sample_positions */ + +#ifdef GL_AMD_seamless_cubemap_per_texture + +#endif /* GL_AMD_seamless_cubemap_per_texture */ + +#ifdef GL_AMD_shader_stencil_export + +#endif /* GL_AMD_shader_stencil_export */ + +#ifdef GL_AMD_texture_texture4 + +#endif /* GL_AMD_texture_texture4 */ + +#ifdef GL_AMD_transform_feedback3_lines_triangles + +#endif /* GL_AMD_transform_feedback3_lines_triangles */ + +#ifdef GL_AMD_vertex_shader_tessellator + +static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r; + r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_vertex_shader_tessellator */ + +#ifdef GL_APPLE_aux_depth_stencil + +#endif /* GL_APPLE_aux_depth_stencil */ + +#ifdef GL_APPLE_client_storage + +#endif /* GL_APPLE_client_storage */ + +#ifdef GL_APPLE_element_array + +static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r; + r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r; + r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r; + r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r; + r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_element_array */ + +#ifdef GL_APPLE_fence + +static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r; + r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r; + r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r; + r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r; + r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r; + r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r; + r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r; + r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_fence */ + +#ifdef GL_APPLE_float_pixels + +#endif /* GL_APPLE_float_pixels */ + +#ifdef GL_APPLE_flush_buffer_range + +static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r; + r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_flush_buffer_range */ + +#ifdef GL_APPLE_object_purgeable + +static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r; + r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r; + r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_object_purgeable */ + +#ifdef GL_APPLE_pixel_buffer + +#endif /* GL_APPLE_pixel_buffer */ + +#ifdef GL_APPLE_rgb_422 + +#endif /* GL_APPLE_rgb_422 */ + +#ifdef GL_APPLE_row_bytes + +#endif /* GL_APPLE_row_bytes */ + +#ifdef GL_APPLE_specular_vector + +#endif /* GL_APPLE_specular_vector */ + +#ifdef GL_APPLE_texture_range + +static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r; + r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_texture_range */ + +#ifdef GL_APPLE_transform_hint + +#endif /* GL_APPLE_transform_hint */ + +#ifdef GL_APPLE_vertex_array_object + +static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r; + r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r; + r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r; + r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_vertex_array_object */ + +#ifdef GL_APPLE_vertex_array_range + +static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r; + r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r; + r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_vertex_array_range */ + +#ifdef GL_APPLE_vertex_program_evaluators + +static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r; + r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r; + r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r; + r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r; + r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r; + r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r; + r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_vertex_program_evaluators */ + +#ifdef GL_APPLE_ycbcr_422 + +#endif /* GL_APPLE_ycbcr_422 */ + +#ifdef GL_ARB_ES2_compatibility + +static GLboolean _glewInit_GL_ARB_ES2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r; + r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r; + r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r; + r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r; + r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_ES2_compatibility */ + +#ifdef GL_ARB_base_instance + +static GLboolean _glewInit_GL_ARB_base_instance (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r; + r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r; + r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_base_instance */ + +#ifdef GL_ARB_blend_func_extended + +static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r; + r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_blend_func_extended */ + +#ifdef GL_ARB_cl_event + +static GLboolean _glewInit_GL_ARB_cl_event (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_cl_event */ + +#ifdef GL_ARB_color_buffer_float + +static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_color_buffer_float */ + +#ifdef GL_ARB_compatibility + +#endif /* GL_ARB_compatibility */ + +#ifdef GL_ARB_compressed_texture_pixel_storage + +#endif /* GL_ARB_compressed_texture_pixel_storage */ + +#ifdef GL_ARB_conservative_depth + +#endif /* GL_ARB_conservative_depth */ + +#ifdef GL_ARB_copy_buffer + +static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_copy_buffer */ + +#ifdef GL_ARB_debug_output + +static GLboolean _glewInit_GL_ARB_debug_output (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r; + r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r; + r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r; + r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_debug_output */ + +#ifdef GL_ARB_depth_buffer_float + +#endif /* GL_ARB_depth_buffer_float */ + +#ifdef GL_ARB_depth_clamp + +#endif /* GL_ARB_depth_clamp */ + +#ifdef GL_ARB_depth_texture + +#endif /* GL_ARB_depth_texture */ + +#ifdef GL_ARB_draw_buffers + +static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_buffers */ + +#ifdef GL_ARB_draw_buffers_blend + +static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r; + r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r; + r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r; + r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_buffers_blend */ + +#ifdef GL_ARB_draw_elements_base_vertex + +static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r; + r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r; + r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r; + r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_elements_base_vertex */ + +#ifdef GL_ARB_draw_indirect + +static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r; + r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_indirect */ + +#ifdef GL_ARB_draw_instanced + +#endif /* GL_ARB_draw_instanced */ + +#ifdef GL_ARB_explicit_attrib_location + +#endif /* GL_ARB_explicit_attrib_location */ + +#ifdef GL_ARB_fragment_coord_conventions + +#endif /* GL_ARB_fragment_coord_conventions */ + +#ifdef GL_ARB_fragment_program + +#endif /* GL_ARB_fragment_program */ + +#ifdef GL_ARB_fragment_program_shadow + +#endif /* GL_ARB_fragment_program_shadow */ + +#ifdef GL_ARB_fragment_shader + +#endif /* GL_ARB_fragment_shader */ + +#ifdef GL_ARB_framebuffer_object + +static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r; + r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r; + r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r; + r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r; + r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r; + r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r; + r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r; + r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r; + r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r; + r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r; + r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r; + r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r; + r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r; + r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r; + r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r; + r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r; + r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r; + r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r; + r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r; + r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_framebuffer_object */ + +#ifdef GL_ARB_framebuffer_sRGB + +#endif /* GL_ARB_framebuffer_sRGB */ + +#ifdef GL_ARB_geometry_shader4 + +static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r; + r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r; + r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r; + r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_geometry_shader4 */ + +#ifdef GL_ARB_get_program_binary + +static GLboolean _glewInit_GL_ARB_get_program_binary (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r; + r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r; + r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_get_program_binary */ + +#ifdef GL_ARB_gpu_shader5 + +#endif /* GL_ARB_gpu_shader5 */ + +#ifdef GL_ARB_gpu_shader_fp64 + +static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r; + r = ((glProgramUniform1dEXT = (PFNGLPROGRAMUNIFORM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dEXT")) == NULL) || r; + r = ((glProgramUniform1dvEXT = (PFNGLPROGRAMUNIFORM1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dvEXT")) == NULL) || r; + r = ((glProgramUniform2dEXT = (PFNGLPROGRAMUNIFORM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dEXT")) == NULL) || r; + r = ((glProgramUniform2dvEXT = (PFNGLPROGRAMUNIFORM2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dvEXT")) == NULL) || r; + r = ((glProgramUniform3dEXT = (PFNGLPROGRAMUNIFORM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dEXT")) == NULL) || r; + r = ((glProgramUniform3dvEXT = (PFNGLPROGRAMUNIFORM3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dvEXT")) == NULL) || r; + r = ((glProgramUniform4dEXT = (PFNGLPROGRAMUNIFORM4DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dEXT")) == NULL) || r; + r = ((glProgramUniform4dvEXT = (PFNGLPROGRAMUNIFORM4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dvEXT")) == NULL) || r; + r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r; + r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r; + r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r; + r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r; + r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r; + r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r; + r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r; + r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r; + r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r; + r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r; + r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r; + r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r; + r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r; + r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r; + r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r; + r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r; + r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_gpu_shader_fp64 */ + +#ifdef GL_ARB_half_float_pixel + +#endif /* GL_ARB_half_float_pixel */ + +#ifdef GL_ARB_half_float_vertex + +#endif /* GL_ARB_half_float_vertex */ + +#ifdef GL_ARB_imaging + +static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; + r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r; + r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r; + r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r; + r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r; + r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r; + r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r; + r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r; + r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r; + r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r; + r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r; + r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r; + r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r; + r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r; + r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r; + r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r; + r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r; + r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r; + r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r; + r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r; + r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r; + r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r; + r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r; + r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r; + r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r; + r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r; + r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r; + r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r; + r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r; + r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r; + r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r; + r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r; + r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_imaging */ + +#ifdef GL_ARB_instanced_arrays + +static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r; + r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r; + r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_instanced_arrays */ + +#ifdef GL_ARB_internalformat_query + +static GLboolean _glewInit_GL_ARB_internalformat_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_internalformat_query */ + +#ifdef GL_ARB_map_buffer_alignment + +#endif /* GL_ARB_map_buffer_alignment */ + +#ifdef GL_ARB_map_buffer_range + +static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r; + r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_map_buffer_range */ + +#ifdef GL_ARB_matrix_palette + +static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r; + r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r; + r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r; + r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r; + r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_matrix_palette */ + +#ifdef GL_ARB_multisample + +static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_multisample */ + +#ifdef GL_ARB_multitexture + +static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r; + r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r; + r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r; + r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r; + r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r; + r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r; + r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r; + r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r; + r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r; + r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r; + r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r; + r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r; + r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r; + r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r; + r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r; + r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r; + r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r; + r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r; + r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r; + r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r; + r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r; + r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r; + r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r; + r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r; + r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r; + r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r; + r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r; + r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r; + r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r; + r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r; + r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r; + r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r; + r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r; + r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_multitexture */ + +#ifdef GL_ARB_occlusion_query + +static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r; + r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r; + r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r; + r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r; + r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r; + r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r; + r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r; + r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_occlusion_query */ + +#ifdef GL_ARB_occlusion_query2 + +#endif /* GL_ARB_occlusion_query2 */ + +#ifdef GL_ARB_pixel_buffer_object + +#endif /* GL_ARB_pixel_buffer_object */ + +#ifdef GL_ARB_point_parameters + +static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r; + r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_point_parameters */ + +#ifdef GL_ARB_point_sprite + +#endif /* GL_ARB_point_sprite */ + +#ifdef GL_ARB_provoking_vertex + +static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_provoking_vertex */ + +#ifdef GL_ARB_robustness + +static GLboolean _glewInit_GL_ARB_robustness (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r; + r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r; + r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r; + r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r; + r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r; + r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r; + r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r; + r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r; + r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r; + r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r; + r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r; + r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r; + r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r; + r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r; + r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r; + r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r; + r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r; + r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r; + r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r; + r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_robustness */ + +#ifdef GL_ARB_sample_shading + +static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_sample_shading */ + +#ifdef GL_ARB_sampler_objects + +static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r; + r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r; + r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r; + r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r; + r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r; + r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r; + r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r; + r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r; + r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r; + r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r; + r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r; + r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r; + r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r; + r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_sampler_objects */ + +#ifdef GL_ARB_seamless_cube_map + +#endif /* GL_ARB_seamless_cube_map */ + +#ifdef GL_ARB_separate_shader_objects + +static GLboolean _glewInit_GL_ARB_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r; + r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r; + r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r; + r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r; + r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r; + r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r; + r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r; + r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r; + r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r; + r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r; + r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r; + r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r; + r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r; + r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r; + r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r; + r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r; + r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r; + r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r; + r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r; + r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r; + r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r; + r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r; + r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r; + r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r; + r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r; + r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r; + r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r; + r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r; + r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r; + r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r; + r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r; + r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r; + r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r; + r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r; + r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r; + r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r; + r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r; + r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r; + r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r; + r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r; + r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r; + r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r; + r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r; + r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r; + r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r; + r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r; + r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r; + r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r; + r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r; + r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r; + r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r; + r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r; + r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r; + r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r; + r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r; + r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r; + r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r; + r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r; + r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r; + r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_separate_shader_objects */ + +#ifdef GL_ARB_shader_atomic_counters + +static GLboolean _glewInit_GL_ARB_shader_atomic_counters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shader_atomic_counters */ + +#ifdef GL_ARB_shader_bit_encoding + +#endif /* GL_ARB_shader_bit_encoding */ + +#ifdef GL_ARB_shader_image_load_store + +static GLboolean _glewInit_GL_ARB_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r; + r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shader_image_load_store */ + +#ifdef GL_ARB_shader_objects + +static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r; + r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r; + r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r; + r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r; + r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r; + r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r; + r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r; + r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r; + r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r; + r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r; + r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r; + r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r; + r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r; + r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r; + r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r; + r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r; + r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r; + r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r; + r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r; + r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r; + r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r; + r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r; + r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r; + r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r; + r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r; + r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r; + r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r; + r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r; + r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r; + r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r; + r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r; + r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r; + r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r; + r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r; + r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r; + r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r; + r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r; + r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r; + r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shader_objects */ + +#ifdef GL_ARB_shader_precision + +#endif /* GL_ARB_shader_precision */ + +#ifdef GL_ARB_shader_stencil_export + +#endif /* GL_ARB_shader_stencil_export */ + +#ifdef GL_ARB_shader_subroutine + +static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r; + r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r; + r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r; + r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r; + r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r; + r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r; + r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r; + r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shader_subroutine */ + +#ifdef GL_ARB_shader_texture_lod + +#endif /* GL_ARB_shader_texture_lod */ + +#ifdef GL_ARB_shading_language_100 + +#endif /* GL_ARB_shading_language_100 */ + +#ifdef GL_ARB_shading_language_420pack + +#endif /* GL_ARB_shading_language_420pack */ + +#ifdef GL_ARB_shading_language_include + +static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r; + r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r; + r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r; + r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r; + r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r; + r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shading_language_include */ + +#ifdef GL_ARB_shading_language_packing + +#endif /* GL_ARB_shading_language_packing */ + +#ifdef GL_ARB_shadow + +#endif /* GL_ARB_shadow */ + +#ifdef GL_ARB_shadow_ambient + +#endif /* GL_ARB_shadow_ambient */ + +#ifdef GL_ARB_sync + +static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r; + r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r; + r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r; + r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r; + r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r; + r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r; + r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_sync */ + +#ifdef GL_ARB_tessellation_shader + +static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r; + r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_tessellation_shader */ + +#ifdef GL_ARB_texture_border_clamp + +#endif /* GL_ARB_texture_border_clamp */ + +#ifdef GL_ARB_texture_buffer_object + +static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_buffer_object */ + +#ifdef GL_ARB_texture_buffer_object_rgb32 + +#endif /* GL_ARB_texture_buffer_object_rgb32 */ + +#ifdef GL_ARB_texture_compression + +static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r; + r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r; + r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r; + r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r; + r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r; + r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r; + r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_compression */ + +#ifdef GL_ARB_texture_compression_bptc + +#endif /* GL_ARB_texture_compression_bptc */ + +#ifdef GL_ARB_texture_compression_rgtc + +#endif /* GL_ARB_texture_compression_rgtc */ + +#ifdef GL_ARB_texture_cube_map + +#endif /* GL_ARB_texture_cube_map */ + +#ifdef GL_ARB_texture_cube_map_array + +#endif /* GL_ARB_texture_cube_map_array */ + +#ifdef GL_ARB_texture_env_add + +#endif /* GL_ARB_texture_env_add */ + +#ifdef GL_ARB_texture_env_combine + +#endif /* GL_ARB_texture_env_combine */ + +#ifdef GL_ARB_texture_env_crossbar + +#endif /* GL_ARB_texture_env_crossbar */ + +#ifdef GL_ARB_texture_env_dot3 + +#endif /* GL_ARB_texture_env_dot3 */ + +#ifdef GL_ARB_texture_float + +#endif /* GL_ARB_texture_float */ + +#ifdef GL_ARB_texture_gather + +#endif /* GL_ARB_texture_gather */ + +#ifdef GL_ARB_texture_mirrored_repeat + +#endif /* GL_ARB_texture_mirrored_repeat */ + +#ifdef GL_ARB_texture_multisample + +static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r; + r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r; + r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r; + r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_multisample */ + +#ifdef GL_ARB_texture_non_power_of_two + +#endif /* GL_ARB_texture_non_power_of_two */ + +#ifdef GL_ARB_texture_query_lod + +#endif /* GL_ARB_texture_query_lod */ + +#ifdef GL_ARB_texture_rectangle + +#endif /* GL_ARB_texture_rectangle */ + +#ifdef GL_ARB_texture_rg + +#endif /* GL_ARB_texture_rg */ + +#ifdef GL_ARB_texture_rgb10_a2ui + +#endif /* GL_ARB_texture_rgb10_a2ui */ + +#ifdef GL_ARB_texture_storage + +static GLboolean _glewInit_GL_ARB_texture_storage (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r; + r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r; + r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r; + r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r; + r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r; + r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_storage */ + +#ifdef GL_ARB_texture_swizzle + +#endif /* GL_ARB_texture_swizzle */ + +#ifdef GL_ARB_timer_query + +static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r; + r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r; + r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_timer_query */ + +#ifdef GL_ARB_transform_feedback2 + +static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r; + r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r; + r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r; + r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r; + r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r; + r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r; + r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_transform_feedback2 */ + +#ifdef GL_ARB_transform_feedback3 + +static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r; + r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r; + r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r; + r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_transform_feedback3 */ + +#ifdef GL_ARB_transform_feedback_instanced + +static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r; + r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_transform_feedback_instanced */ + +#ifdef GL_ARB_transpose_matrix + +static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r; + r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r; + r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r; + r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_transpose_matrix */ + +#ifdef GL_ARB_uniform_buffer_object + +static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r; + r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r; + r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r; + r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r; + r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r; + r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r; + r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r; + r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r; + r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r; + r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_uniform_buffer_object */ + +#ifdef GL_ARB_vertex_array_bgra + +#endif /* GL_ARB_vertex_array_bgra */ + +#ifdef GL_ARB_vertex_array_object + +static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r; + r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r; + r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r; + r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_array_object */ + +#ifdef GL_ARB_vertex_attrib_64bit + +static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r; + r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r; + r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r; + r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r; + r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r; + r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r; + r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r; + r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r; + r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r; + r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_attrib_64bit */ + +#ifdef GL_ARB_vertex_blend + +static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r; + r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r; + r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r; + r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r; + r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r; + r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r; + r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r; + r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r; + r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r; + r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_blend */ + +#ifdef GL_ARB_vertex_buffer_object + +static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r; + r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r; + r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r; + r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r; + r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r; + r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r; + r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r; + r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r; + r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r; + r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r; + r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_buffer_object */ + +#ifdef GL_ARB_vertex_program + +static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r; + r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r; + r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r; + r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r; + r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r; + r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r; + r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r; + r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r; + r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r; + r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r; + r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r; + r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r; + r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r; + r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r; + r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r; + r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r; + r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r; + r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r; + r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r; + r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r; + r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r; + r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r; + r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r; + r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r; + r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r; + r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r; + r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r; + r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r; + r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r; + r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r; + r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r; + r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r; + r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r; + r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r; + r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r; + r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r; + r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r; + r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r; + r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r; + r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r; + r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r; + r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r; + r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r; + r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r; + r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r; + r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r; + r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r; + r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r; + r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r; + r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r; + r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r; + r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r; + r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r; + r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r; + r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r; + r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r; + r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r; + r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r; + r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r; + r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r; + r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r; + r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_program */ + +#ifdef GL_ARB_vertex_shader + +static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r; + r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r; + r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_shader */ + +#ifdef GL_ARB_vertex_type_2_10_10_10_rev + +static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r; + r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r; + r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r; + r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r; + r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r; + r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r; + r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r; + r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r; + r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r; + r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r; + r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r; + r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r; + r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r; + r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r; + r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r; + r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r; + r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r; + r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r; + r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r; + r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r; + r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r; + r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r; + r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r; + r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r; + r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r; + r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r; + r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r; + r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r; + r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r; + r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r; + r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r; + r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r; + r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r; + r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r; + r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r; + r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r; + r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r; + r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_type_2_10_10_10_rev */ + +#ifdef GL_ARB_viewport_array + +static GLboolean _glewInit_GL_ARB_viewport_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r; + r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r; + r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r; + r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r; + r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r; + r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r; + r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r; + r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r; + r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r; + r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_viewport_array */ + +#ifdef GL_ARB_window_pos + +static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r; + r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r; + r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r; + r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r; + r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r; + r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r; + r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r; + r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r; + r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r; + r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r; + r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r; + r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r; + r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r; + r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r; + r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r; + r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_window_pos */ + +#ifdef GL_ATIX_point_sprites + +#endif /* GL_ATIX_point_sprites */ + +#ifdef GL_ATIX_texture_env_combine3 + +#endif /* GL_ATIX_texture_env_combine3 */ + +#ifdef GL_ATIX_texture_env_route + +#endif /* GL_ATIX_texture_env_route */ + +#ifdef GL_ATIX_vertex_shader_output_point_size + +#endif /* GL_ATIX_vertex_shader_output_point_size */ + +#ifdef GL_ATI_draw_buffers + +static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_draw_buffers */ + +#ifdef GL_ATI_element_array + +static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r; + r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r; + r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_element_array */ + +#ifdef GL_ATI_envmap_bumpmap + +static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r; + r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r; + r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r; + r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_envmap_bumpmap */ + +#ifdef GL_ATI_fragment_shader + +static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r; + r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r; + r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r; + r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r; + r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r; + r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r; + r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r; + r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r; + r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r; + r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r; + r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r; + r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r; + r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r; + r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_fragment_shader */ + +#ifdef GL_ATI_map_object_buffer + +static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r; + r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_map_object_buffer */ + +#ifdef GL_ATI_meminfo + +#endif /* GL_ATI_meminfo */ + +#ifdef GL_ATI_pn_triangles + +static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r; + r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_pn_triangles */ + +#ifdef GL_ATI_separate_stencil + +static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r; + r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_separate_stencil */ + +#ifdef GL_ATI_shader_texture_lod + +#endif /* GL_ATI_shader_texture_lod */ + +#ifdef GL_ATI_text_fragment_shader + +#endif /* GL_ATI_text_fragment_shader */ + +#ifdef GL_ATI_texture_compression_3dc + +#endif /* GL_ATI_texture_compression_3dc */ + +#ifdef GL_ATI_texture_env_combine3 + +#endif /* GL_ATI_texture_env_combine3 */ + +#ifdef GL_ATI_texture_float + +#endif /* GL_ATI_texture_float */ + +#ifdef GL_ATI_texture_mirror_once + +#endif /* GL_ATI_texture_mirror_once */ + +#ifdef GL_ATI_vertex_array_object + +static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r; + r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r; + r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r; + r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r; + r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r; + r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r; + r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r; + r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r; + r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r; + r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r; + r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r; + r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_array_object */ + +#ifdef GL_ATI_vertex_attrib_array_object + +static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r; + r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r; + r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_attrib_array_object */ + +#ifdef GL_ATI_vertex_streams + +static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r; + r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r; + r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r; + r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r; + r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r; + r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r; + r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r; + r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r; + r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r; + r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r; + r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r; + r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r; + r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r; + r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r; + r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r; + r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r; + r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r; + r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r; + r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r; + r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r; + r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r; + r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r; + r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r; + r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r; + r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r; + r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r; + r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r; + r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r; + r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r; + r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r; + r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r; + r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r; + r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r; + r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r; + r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r; + r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r; + r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_streams */ + +#ifdef GL_EXT_422_pixels + +#endif /* GL_EXT_422_pixels */ + +#ifdef GL_EXT_Cg_shader + +#endif /* GL_EXT_Cg_shader */ + +#ifdef GL_EXT_abgr + +#endif /* GL_EXT_abgr */ + +#ifdef GL_EXT_bgra + +#endif /* GL_EXT_bgra */ + +#ifdef GL_EXT_bindable_uniform + +static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r; + r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r; + r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_bindable_uniform */ + +#ifdef GL_EXT_blend_color + +static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_color */ + +#ifdef GL_EXT_blend_equation_separate + +static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_equation_separate */ + +#ifdef GL_EXT_blend_func_separate + +static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_func_separate */ + +#ifdef GL_EXT_blend_logic_op + +#endif /* GL_EXT_blend_logic_op */ + +#ifdef GL_EXT_blend_minmax + +static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_minmax */ + +#ifdef GL_EXT_blend_subtract + +#endif /* GL_EXT_blend_subtract */ + +#ifdef GL_EXT_clip_volume_hint + +#endif /* GL_EXT_clip_volume_hint */ + +#ifdef GL_EXT_cmyka + +#endif /* GL_EXT_cmyka */ + +#ifdef GL_EXT_color_subtable + +static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r; + r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_color_subtable */ + +#ifdef GL_EXT_compiled_vertex_array + +static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r; + r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_compiled_vertex_array */ + +#ifdef GL_EXT_convolution + +static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r; + r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r; + r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r; + r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r; + r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r; + r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r; + r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r; + r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r; + r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r; + r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r; + r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r; + r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r; + r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_convolution */ + +#ifdef GL_EXT_coordinate_frame + +static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r; + r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_coordinate_frame */ + +#ifdef GL_EXT_copy_texture + +static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r; + r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r; + r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r; + r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r; + r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_copy_texture */ + +#ifdef GL_EXT_cull_vertex + +static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r; + r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_cull_vertex */ + +#ifdef GL_EXT_depth_bounds_test + +static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_depth_bounds_test */ + +#ifdef GL_EXT_direct_state_access + +static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r; + r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r; + r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r; + r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r; + r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r; + r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r; + r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r; + r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r; + r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r; + r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r; + r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r; + r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r; + r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r; + r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r; + r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r; + r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r; + r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r; + r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r; + r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r; + r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r; + r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r; + r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r; + r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r; + r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r; + r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r; + r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r; + r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r; + r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r; + r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r; + r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r; + r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r; + r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r; + r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r; + r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r; + r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r; + r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r; + r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r; + r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r; + r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r; + r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r; + r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r; + r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r; + r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r; + r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r; + r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r; + r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r; + r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r; + r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r; + r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r; + r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r; + r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r; + r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r; + r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r; + r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r; + r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r; + r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r; + r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r; + r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r; + r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r; + r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r; + r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r; + r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r; + r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r; + r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r; + r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r; + r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r; + r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r; + r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r; + r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r; + r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r; + r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r; + r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r; + r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r; + r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r; + r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r; + r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r; + r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r; + r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r; + r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r; + r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r; + r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r; + r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r; + r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r; + r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r; + r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r; + r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r; + r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r; + r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r; + r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r; + r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r; + r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r; + r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r; + r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r; + r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r; + r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r; + r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r; + r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r; + r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r; + r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r; + r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r; + r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r; + r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r; + r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r; + r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r; + r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r; + r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r; + r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r; + r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r; + r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r; + r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r; + r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r; + r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r; + r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r; + r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r; + r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r; + r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r; + r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r; + r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r; + r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r; + r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r; + r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r; + r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r; + r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r; + r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r; + r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r; + r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r; + r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r; + r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r; + r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r; + r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r; + r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r; + r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r; + r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r; + r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r; + r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r; + r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r; + r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r; + r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r; + r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r; + r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r; + r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r; + r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r; + r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r; + r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r; + r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r; + r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r; + r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r; + r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r; + r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r; + r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r; + r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r; + r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r; + r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r; + r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r; + r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r; + r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r; + r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_direct_state_access */ + +#ifdef GL_EXT_draw_buffers2 + +static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r; + r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r; + r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r; + r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r; + r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r; + r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_buffers2 */ + +#ifdef GL_EXT_draw_instanced + +static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r; + r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_instanced */ + +#ifdef GL_EXT_draw_range_elements + +static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_range_elements */ + +#ifdef GL_EXT_fog_coord + +static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r; + r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r; + r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r; + r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r; + r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_fog_coord */ + +#ifdef GL_EXT_fragment_lighting + +static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r; + r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r; + r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r; + r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r; + r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r; + r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r; + r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r; + r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r; + r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r; + r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r; + r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r; + r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r; + r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r; + r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r; + r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r; + r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r; + r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r; + r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_fragment_lighting */ + +#ifdef GL_EXT_framebuffer_blit + +static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_blit */ + +#ifdef GL_EXT_framebuffer_multisample + +static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_multisample */ + +#ifdef GL_EXT_framebuffer_multisample_blit_scaled + +#endif /* GL_EXT_framebuffer_multisample_blit_scaled */ + +#ifdef GL_EXT_framebuffer_object + +static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r; + r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r; + r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r; + r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r; + r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r; + r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r; + r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r; + r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r; + r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r; + r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r; + r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r; + r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r; + r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r; + r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r; + r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r; + r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r; + r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_object */ + +#ifdef GL_EXT_framebuffer_sRGB + +#endif /* GL_EXT_framebuffer_sRGB */ + +#ifdef GL_EXT_geometry_shader4 + +static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r; + r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r; + r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_geometry_shader4 */ + +#ifdef GL_EXT_gpu_program_parameters + +static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r; + r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_gpu_program_parameters */ + +#ifdef GL_EXT_gpu_shader4 + +static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r; + r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r; + r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r; + r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r; + r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r; + r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r; + r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r; + r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r; + r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r; + r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r; + r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r; + r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r; + r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r; + r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r; + r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r; + r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r; + r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r; + r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r; + r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r; + r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r; + r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r; + r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r; + r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r; + r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r; + r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r; + r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r; + r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r; + r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r; + r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r; + r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r; + r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r; + r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r; + r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r; + r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_gpu_shader4 */ + +#ifdef GL_EXT_histogram + +static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r; + r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r; + r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r; + r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r; + r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r; + r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r; + r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r; + r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r; + r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r; + r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_histogram */ + +#ifdef GL_EXT_index_array_formats + +#endif /* GL_EXT_index_array_formats */ + +#ifdef GL_EXT_index_func + +static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_index_func */ + +#ifdef GL_EXT_index_material + +static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_index_material */ + +#ifdef GL_EXT_index_texture + +#endif /* GL_EXT_index_texture */ + +#ifdef GL_EXT_light_texture + +static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r; + r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r; + r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_light_texture */ + +#ifdef GL_EXT_misc_attribute + +#endif /* GL_EXT_misc_attribute */ + +#ifdef GL_EXT_multi_draw_arrays + +static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r; + r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multi_draw_arrays */ + +#ifdef GL_EXT_multisample + +static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r; + r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multisample */ + +#ifdef GL_EXT_packed_depth_stencil + +#endif /* GL_EXT_packed_depth_stencil */ + +#ifdef GL_EXT_packed_float + +#endif /* GL_EXT_packed_float */ + +#ifdef GL_EXT_packed_pixels + +#endif /* GL_EXT_packed_pixels */ + +#ifdef GL_EXT_paletted_texture + +static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r; + r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r; + r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r; + r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_paletted_texture */ + +#ifdef GL_EXT_pixel_buffer_object + +#endif /* GL_EXT_pixel_buffer_object */ + +#ifdef GL_EXT_pixel_transform + +static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r; + r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r; + r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r; + r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r; + r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r; + r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_pixel_transform */ + +#ifdef GL_EXT_pixel_transform_color_table + +#endif /* GL_EXT_pixel_transform_color_table */ + +#ifdef GL_EXT_point_parameters + +static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r; + r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_point_parameters */ + +#ifdef GL_EXT_polygon_offset + +static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_polygon_offset */ + +#ifdef GL_EXT_provoking_vertex + +static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_provoking_vertex */ + +#ifdef GL_EXT_rescale_normal + +#endif /* GL_EXT_rescale_normal */ + +#ifdef GL_EXT_scene_marker + +static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r; + r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_scene_marker */ + +#ifdef GL_EXT_secondary_color + +static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r; + r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r; + r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r; + r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r; + r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r; + r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r; + r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r; + r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r; + r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r; + r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r; + r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r; + r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r; + r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r; + r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r; + r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r; + r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r; + r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_secondary_color */ + +#ifdef GL_EXT_separate_shader_objects + +static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r; + r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r; + r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_separate_shader_objects */ + +#ifdef GL_EXT_separate_specular_color + +#endif /* GL_EXT_separate_specular_color */ + +#ifdef GL_EXT_shader_image_load_store + +static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r; + r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_shader_image_load_store */ + +#ifdef GL_EXT_shadow_funcs + +#endif /* GL_EXT_shadow_funcs */ + +#ifdef GL_EXT_shared_texture_palette + +#endif /* GL_EXT_shared_texture_palette */ + +#ifdef GL_EXT_stencil_clear_tag + +#endif /* GL_EXT_stencil_clear_tag */ + +#ifdef GL_EXT_stencil_two_side + +static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_stencil_two_side */ + +#ifdef GL_EXT_stencil_wrap + +#endif /* GL_EXT_stencil_wrap */ + +#ifdef GL_EXT_subtexture + +static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r; + r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r; + r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_subtexture */ + +#ifdef GL_EXT_texture + +#endif /* GL_EXT_texture */ + +#ifdef GL_EXT_texture3D + +static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture3D */ + +#ifdef GL_EXT_texture_array + +static GLboolean _glewInit_GL_EXT_texture_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_array */ + +#ifdef GL_EXT_texture_buffer_object + +static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_buffer_object */ + +#ifdef GL_EXT_texture_compression_dxt1 + +#endif /* GL_EXT_texture_compression_dxt1 */ + +#ifdef GL_EXT_texture_compression_latc + +#endif /* GL_EXT_texture_compression_latc */ + +#ifdef GL_EXT_texture_compression_rgtc + +#endif /* GL_EXT_texture_compression_rgtc */ + +#ifdef GL_EXT_texture_compression_s3tc + +#endif /* GL_EXT_texture_compression_s3tc */ + +#ifdef GL_EXT_texture_cube_map + +#endif /* GL_EXT_texture_cube_map */ + +#ifdef GL_EXT_texture_edge_clamp + +#endif /* GL_EXT_texture_edge_clamp */ + +#ifdef GL_EXT_texture_env + +#endif /* GL_EXT_texture_env */ + +#ifdef GL_EXT_texture_env_add + +#endif /* GL_EXT_texture_env_add */ + +#ifdef GL_EXT_texture_env_combine + +#endif /* GL_EXT_texture_env_combine */ + +#ifdef GL_EXT_texture_env_dot3 + +#endif /* GL_EXT_texture_env_dot3 */ + +#ifdef GL_EXT_texture_filter_anisotropic + +#endif /* GL_EXT_texture_filter_anisotropic */ + +#ifdef GL_EXT_texture_integer + +static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r; + r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r; + r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r; + r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r; + r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r; + r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_integer */ + +#ifdef GL_EXT_texture_lod_bias + +#endif /* GL_EXT_texture_lod_bias */ + +#ifdef GL_EXT_texture_mirror_clamp + +#endif /* GL_EXT_texture_mirror_clamp */ + +#ifdef GL_EXT_texture_object + +static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r; + r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r; + r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r; + r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r; + r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r; + r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_object */ + +#ifdef GL_EXT_texture_perturb_normal + +static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_perturb_normal */ + +#ifdef GL_EXT_texture_rectangle + +#endif /* GL_EXT_texture_rectangle */ + +#ifdef GL_EXT_texture_sRGB + +#endif /* GL_EXT_texture_sRGB */ + +#ifdef GL_EXT_texture_sRGB_decode + +#endif /* GL_EXT_texture_sRGB_decode */ + +#ifdef GL_EXT_texture_shared_exponent + +#endif /* GL_EXT_texture_shared_exponent */ + +#ifdef GL_EXT_texture_snorm + +#endif /* GL_EXT_texture_snorm */ + +#ifdef GL_EXT_texture_swizzle + +#endif /* GL_EXT_texture_swizzle */ + +#ifdef GL_EXT_timer_query + +static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r; + r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_timer_query */ + +#ifdef GL_EXT_transform_feedback + +static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r; + r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r; + r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r; + r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r; + r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r; + r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r; + r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_transform_feedback */ + +#ifdef GL_EXT_vertex_array + +static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r; + r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r; + r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r; + r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r; + r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r; + r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r; + r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r; + r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_array */ + +#ifdef GL_EXT_vertex_array_bgra + +#endif /* GL_EXT_vertex_array_bgra */ + +#ifdef GL_EXT_vertex_attrib_64bit + +static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r; + r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r; + r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r; + r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r; + r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r; + r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r; + r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r; + r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r; + r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r; + r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r; + r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_attrib_64bit */ + +#ifdef GL_EXT_vertex_shader + +static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r; + r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r; + r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r; + r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r; + r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r; + r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r; + r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r; + r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r; + r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r; + r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r; + r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r; + r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r; + r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r; + r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r; + r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r; + r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r; + r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r; + r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r; + r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r; + r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r; + r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r; + r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r; + r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r; + r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r; + r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r; + r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r; + r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r; + r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r; + r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r; + r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r; + r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r; + r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r; + r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r; + r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r; + r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r; + r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r; + r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r; + r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r; + r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r; + r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r; + r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r; + r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_shader */ + +#ifdef GL_EXT_vertex_weighting + +static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r; + r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r; + r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_weighting */ + +#ifdef GL_EXT_x11_sync_object + +static GLboolean _glewInit_GL_EXT_x11_sync_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_x11_sync_object */ + +#ifdef GL_GREMEDY_frame_terminator + +static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r; + + return r; +} + +#endif /* GL_GREMEDY_frame_terminator */ + +#ifdef GL_GREMEDY_string_marker + +static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r; + + return r; +} + +#endif /* GL_GREMEDY_string_marker */ + +#ifdef GL_HP_convolution_border_modes + +#endif /* GL_HP_convolution_border_modes */ + +#ifdef GL_HP_image_transform + +static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r; + r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r; + r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r; + r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r; + r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r; + r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r; + + return r; +} + +#endif /* GL_HP_image_transform */ + +#ifdef GL_HP_occlusion_test + +#endif /* GL_HP_occlusion_test */ + +#ifdef GL_HP_texture_lighting + +#endif /* GL_HP_texture_lighting */ + +#ifdef GL_IBM_cull_vertex + +#endif /* GL_IBM_cull_vertex */ + +#ifdef GL_IBM_multimode_draw_arrays + +static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r; + r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r; + + return r; +} + +#endif /* GL_IBM_multimode_draw_arrays */ + +#ifdef GL_IBM_rasterpos_clip + +#endif /* GL_IBM_rasterpos_clip */ + +#ifdef GL_IBM_static_data + +#endif /* GL_IBM_static_data */ + +#ifdef GL_IBM_texture_mirrored_repeat + +#endif /* GL_IBM_texture_mirrored_repeat */ + +#ifdef GL_IBM_vertex_array_lists + +static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r; + r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r; + r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r; + r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r; + r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r; + r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r; + r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r; + r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r; + + return r; +} + +#endif /* GL_IBM_vertex_array_lists */ + +#ifdef GL_INGR_color_clamp + +#endif /* GL_INGR_color_clamp */ + +#ifdef GL_INGR_interlace_read + +#endif /* GL_INGR_interlace_read */ + +#ifdef GL_INTEL_parallel_arrays + +static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r; + r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r; + r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r; + r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r; + + return r; +} + +#endif /* GL_INTEL_parallel_arrays */ + +#ifdef GL_INTEL_texture_scissor + +static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r; + r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r; + + return r; +} + +#endif /* GL_INTEL_texture_scissor */ + +#ifdef GL_KTX_buffer_region + +static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r; + r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r; + r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r; + r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r; + r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r; + + return r; +} + +#endif /* GL_KTX_buffer_region */ + +#ifdef GL_MESAX_texture_stack + +#endif /* GL_MESAX_texture_stack */ + +#ifdef GL_MESA_pack_invert + +#endif /* GL_MESA_pack_invert */ + +#ifdef GL_MESA_resize_buffers + +static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r; + + return r; +} + +#endif /* GL_MESA_resize_buffers */ + +#ifdef GL_MESA_window_pos + +static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r; + r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r; + r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r; + r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r; + r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r; + r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r; + r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r; + r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r; + r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r; + r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r; + r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r; + r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r; + r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r; + r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r; + r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r; + r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r; + r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r; + r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r; + r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r; + r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r; + r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r; + r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r; + r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r; + r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r; + + return r; +} + +#endif /* GL_MESA_window_pos */ + +#ifdef GL_MESA_ycbcr_texture + +#endif /* GL_MESA_ycbcr_texture */ + +#ifdef GL_NVX_gpu_memory_info + +#endif /* GL_NVX_gpu_memory_info */ + +#ifdef GL_NV_blend_square + +#endif /* GL_NV_blend_square */ + +#ifdef GL_NV_conditional_render + +static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r; + r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_conditional_render */ + +#ifdef GL_NV_copy_depth_to_color + +#endif /* GL_NV_copy_depth_to_color */ + +#ifdef GL_NV_copy_image + +static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_copy_image */ + +#ifdef GL_NV_depth_buffer_float + +static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r; + r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r; + r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_depth_buffer_float */ + +#ifdef GL_NV_depth_clamp + +#endif /* GL_NV_depth_clamp */ + +#ifdef GL_NV_depth_range_unclamped + +#endif /* GL_NV_depth_range_unclamped */ + +#ifdef GL_NV_evaluators + +static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r; + r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r; + r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r; + r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r; + r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r; + r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r; + r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r; + r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r; + r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_evaluators */ + +#ifdef GL_NV_explicit_multisample + +static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r; + r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r; + r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_explicit_multisample */ + +#ifdef GL_NV_fence + +static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r; + r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r; + r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r; + r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r; + r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r; + r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r; + r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_fence */ + +#ifdef GL_NV_float_buffer + +#endif /* GL_NV_float_buffer */ + +#ifdef GL_NV_fog_distance + +#endif /* GL_NV_fog_distance */ + +#ifdef GL_NV_fragment_program + +static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r; + r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r; + r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r; + r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r; + r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r; + r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_fragment_program */ + +#ifdef GL_NV_fragment_program2 + +#endif /* GL_NV_fragment_program2 */ + +#ifdef GL_NV_fragment_program4 + +#endif /* GL_NV_fragment_program4 */ + +#ifdef GL_NV_fragment_program_option + +#endif /* GL_NV_fragment_program_option */ + +#ifdef GL_NV_framebuffer_multisample_coverage + +static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_framebuffer_multisample_coverage */ + +#ifdef GL_NV_geometry_program4 + +static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_geometry_program4 */ + +#ifdef GL_NV_geometry_shader4 + +#endif /* GL_NV_geometry_shader4 */ + +#ifdef GL_NV_gpu_program4 + +static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r; + r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r; + r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r; + r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r; + r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r; + r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r; + r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r; + r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r; + r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r; + r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r; + r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r; + r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_gpu_program4 */ + +#ifdef GL_NV_gpu_program5 + +#endif /* GL_NV_gpu_program5 */ + +#ifdef GL_NV_gpu_program_fp64 + +#endif /* GL_NV_gpu_program_fp64 */ + +#ifdef GL_NV_gpu_shader5 + +static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r; + r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r; + r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r; + r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r; + r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r; + r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r; + r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r; + r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r; + r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r; + r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r; + r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r; + r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r; + r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r; + r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r; + r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r; + r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r; + r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r; + r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r; + r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r; + r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r; + r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r; + r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r; + r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r; + r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r; + r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r; + r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r; + r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r; + r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r; + r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r; + r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r; + r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r; + r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r; + r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r; + r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_gpu_shader5 */ + +#ifdef GL_NV_half_float + +static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r; + r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r; + r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r; + r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r; + r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r; + r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r; + r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r; + r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r; + r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r; + r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r; + r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r; + r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r; + r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r; + r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r; + r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r; + r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r; + r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r; + r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r; + r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r; + r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r; + r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r; + r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r; + r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r; + r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r; + r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r; + r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r; + r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r; + r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r; + r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r; + r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r; + r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r; + r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r; + r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r; + r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r; + r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r; + r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r; + r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r; + r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r; + r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r; + r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r; + r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r; + r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r; + r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r; + r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r; + r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r; + r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_half_float */ + +#ifdef GL_NV_light_max_exponent + +#endif /* GL_NV_light_max_exponent */ + +#ifdef GL_NV_multisample_coverage + +#endif /* GL_NV_multisample_coverage */ + +#ifdef GL_NV_multisample_filter_hint + +#endif /* GL_NV_multisample_filter_hint */ + +#ifdef GL_NV_occlusion_query + +static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r; + r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r; + r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r; + r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r; + r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r; + r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r; + r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_occlusion_query */ + +#ifdef GL_NV_packed_depth_stencil + +#endif /* GL_NV_packed_depth_stencil */ + +#ifdef GL_NV_parameter_buffer_object + +static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r; + r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r; + r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_parameter_buffer_object */ + +#ifdef GL_NV_parameter_buffer_object2 + +#endif /* GL_NV_parameter_buffer_object2 */ + +#ifdef GL_NV_path_rendering + +static GLboolean _glewInit_GL_NV_path_rendering (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r; + r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r; + r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r; + r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r; + r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r; + r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r; + r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r; + r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r; + r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r; + r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r; + r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r; + r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r; + r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r; + r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r; + r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r; + r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r; + r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r; + r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r; + r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r; + r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r; + r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r; + r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r; + r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r; + r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r; + r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r; + r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r; + r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r; + r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r; + r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r; + r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r; + r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r; + r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r; + r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r; + r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r; + r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r; + r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r; + r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r; + r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r; + r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r; + r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r; + r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r; + r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r; + r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r; + r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r; + r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r; + r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r; + r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r; + r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r; + r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_path_rendering */ + +#ifdef GL_NV_pixel_data_range + +static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r; + r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_pixel_data_range */ + +#ifdef GL_NV_point_sprite + +static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r; + r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_point_sprite */ + +#ifdef GL_NV_present_video + +static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r; + r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r; + r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r; + r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r; + r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r; + r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_present_video */ + +#ifdef GL_NV_primitive_restart + +static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r; + r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_primitive_restart */ + +#ifdef GL_NV_register_combiners + +static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r; + r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r; + r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r; + r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r; + r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r; + r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r; + r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r; + r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r; + r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r; + r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r; + r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r; + r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r; + r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_register_combiners */ + +#ifdef GL_NV_register_combiners2 + +static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r; + r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_register_combiners2 */ + +#ifdef GL_NV_shader_buffer_load + +static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r; + r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r; + r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r; + r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r; + r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r; + r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r; + r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r; + r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r; + r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r; + r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r; + r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r; + r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r; + r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_shader_buffer_load */ + +#ifdef GL_NV_tessellation_program5 + +#endif /* GL_NV_tessellation_program5 */ + +#ifdef GL_NV_texgen_emboss + +#endif /* GL_NV_texgen_emboss */ + +#ifdef GL_NV_texgen_reflection + +#endif /* GL_NV_texgen_reflection */ + +#ifdef GL_NV_texture_barrier + +static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_texture_barrier */ + +#ifdef GL_NV_texture_compression_vtc + +#endif /* GL_NV_texture_compression_vtc */ + +#ifdef GL_NV_texture_env_combine4 + +#endif /* GL_NV_texture_env_combine4 */ + +#ifdef GL_NV_texture_expand_normal + +#endif /* GL_NV_texture_expand_normal */ + +#ifdef GL_NV_texture_multisample + +static GLboolean _glewInit_GL_NV_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r; + r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r; + r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r; + r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r; + r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r; + r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_texture_multisample */ + +#ifdef GL_NV_texture_rectangle + +#endif /* GL_NV_texture_rectangle */ + +#ifdef GL_NV_texture_shader + +#endif /* GL_NV_texture_shader */ + +#ifdef GL_NV_texture_shader2 + +#endif /* GL_NV_texture_shader2 */ + +#ifdef GL_NV_texture_shader3 + +#endif /* GL_NV_texture_shader3 */ + +#ifdef GL_NV_transform_feedback + +static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r; + r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r; + r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r; + r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r; + r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r; + r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r; + r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r; + r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r; + r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r; + r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r; + r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_transform_feedback */ + +#ifdef GL_NV_transform_feedback2 + +static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r; + r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r; + r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r; + r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r; + r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r; + r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r; + r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_transform_feedback2 */ + +#ifdef GL_NV_vdpau_interop + +static GLboolean _glewInit_GL_NV_vdpau_interop (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r; + r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r; + r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r; + r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r; + r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r; + r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r; + r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r; + r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r; + r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r; + r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vdpau_interop */ + +#ifdef GL_NV_vertex_array_range + +static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r; + r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_array_range */ + +#ifdef GL_NV_vertex_array_range2 + +#endif /* GL_NV_vertex_array_range2 */ + +#ifdef GL_NV_vertex_attrib_integer_64bit + +static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r; + r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r; + r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r; + r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r; + r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r; + r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r; + r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r; + r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r; + r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r; + r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r; + r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r; + r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r; + r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r; + r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r; + r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r; + r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r; + r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r; + r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r; + r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_attrib_integer_64bit */ + +#ifdef GL_NV_vertex_buffer_unified_memory + +static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r; + r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r; + r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r; + r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r; + r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r; + r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r; + r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r; + r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r; + r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r; + r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r; + r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r; + r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_buffer_unified_memory */ + +#ifdef GL_NV_vertex_program + +static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r; + r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r; + r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r; + r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r; + r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r; + r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r; + r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r; + r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r; + r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r; + r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r; + r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r; + r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r; + r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r; + r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r; + r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r; + r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r; + r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r; + r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r; + r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r; + r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r; + r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r; + r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r; + r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r; + r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r; + r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r; + r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r; + r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r; + r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r; + r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r; + r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r; + r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r; + r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r; + r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r; + r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r; + r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r; + r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r; + r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r; + r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r; + r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r; + r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r; + r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r; + r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r; + r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r; + r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r; + r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r; + r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r; + r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r; + r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r; + r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r; + r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r; + r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r; + r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r; + r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r; + r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r; + r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r; + r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r; + r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r; + r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r; + r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r; + r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r; + r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r; + r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r; + r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r; + r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_program */ + +#ifdef GL_NV_vertex_program1_1 + +#endif /* GL_NV_vertex_program1_1 */ + +#ifdef GL_NV_vertex_program2 + +#endif /* GL_NV_vertex_program2 */ + +#ifdef GL_NV_vertex_program2_option + +#endif /* GL_NV_vertex_program2_option */ + +#ifdef GL_NV_vertex_program3 + +#endif /* GL_NV_vertex_program3 */ + +#ifdef GL_NV_vertex_program4 + +#endif /* GL_NV_vertex_program4 */ + +#ifdef GL_NV_video_capture + +static GLboolean _glewInit_GL_NV_video_capture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r; + r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r; + r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r; + r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r; + r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r; + r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r; + r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r; + r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r; + r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r; + r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r; + r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r; + r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_video_capture */ + +#ifdef GL_OES_byte_coordinates + +#endif /* GL_OES_byte_coordinates */ + +#ifdef GL_OES_compressed_paletted_texture + +#endif /* GL_OES_compressed_paletted_texture */ + +#ifdef GL_OES_read_format + +#endif /* GL_OES_read_format */ + +#ifdef GL_OES_single_precision + +static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r; + r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r; + r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r; + r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r; + r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r; + r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_single_precision */ + +#ifdef GL_OML_interlace + +#endif /* GL_OML_interlace */ + +#ifdef GL_OML_resample + +#endif /* GL_OML_resample */ + +#ifdef GL_OML_subsample + +#endif /* GL_OML_subsample */ + +#ifdef GL_PGI_misc_hints + +#endif /* GL_PGI_misc_hints */ + +#ifdef GL_PGI_vertex_hints + +#endif /* GL_PGI_vertex_hints */ + +#ifdef GL_REND_screen_coordinates + +#endif /* GL_REND_screen_coordinates */ + +#ifdef GL_S3_s3tc + +#endif /* GL_S3_s3tc */ + +#ifdef GL_SGIS_color_range + +#endif /* GL_SGIS_color_range */ + +#ifdef GL_SGIS_detail_texture + +static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r; + r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_detail_texture */ + +#ifdef GL_SGIS_fog_function + +static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r; + r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_fog_function */ + +#ifdef GL_SGIS_generate_mipmap + +#endif /* GL_SGIS_generate_mipmap */ + +#ifdef GL_SGIS_multisample + +static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r; + r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_multisample */ + +#ifdef GL_SGIS_pixel_texture + +#endif /* GL_SGIS_pixel_texture */ + +#ifdef GL_SGIS_point_line_texgen + +#endif /* GL_SGIS_point_line_texgen */ + +#ifdef GL_SGIS_sharpen_texture + +static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r; + r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_sharpen_texture */ + +#ifdef GL_SGIS_texture4D + +static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r; + r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_texture4D */ + +#ifdef GL_SGIS_texture_border_clamp + +#endif /* GL_SGIS_texture_border_clamp */ + +#ifdef GL_SGIS_texture_edge_clamp + +#endif /* GL_SGIS_texture_edge_clamp */ + +#ifdef GL_SGIS_texture_filter4 + +static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r; + r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_texture_filter4 */ + +#ifdef GL_SGIS_texture_lod + +#endif /* GL_SGIS_texture_lod */ + +#ifdef GL_SGIS_texture_select + +#endif /* GL_SGIS_texture_select */ + +#ifdef GL_SGIX_async + +static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r; + r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r; + r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r; + r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r; + r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r; + r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_async */ + +#ifdef GL_SGIX_async_histogram + +#endif /* GL_SGIX_async_histogram */ + +#ifdef GL_SGIX_async_pixel + +#endif /* GL_SGIX_async_pixel */ + +#ifdef GL_SGIX_blend_alpha_minmax + +#endif /* GL_SGIX_blend_alpha_minmax */ + +#ifdef GL_SGIX_clipmap + +#endif /* GL_SGIX_clipmap */ + +#ifdef GL_SGIX_convolution_accuracy + +#endif /* GL_SGIX_convolution_accuracy */ + +#ifdef GL_SGIX_depth_texture + +#endif /* GL_SGIX_depth_texture */ + +#ifdef GL_SGIX_flush_raster + +static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_flush_raster */ + +#ifdef GL_SGIX_fog_offset + +#endif /* GL_SGIX_fog_offset */ + +#ifdef GL_SGIX_fog_texture + +static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_fog_texture */ + +#ifdef GL_SGIX_fragment_specular_lighting + +static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r; + r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r; + r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r; + r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r; + r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r; + r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r; + r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r; + r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r; + r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r; + r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r; + r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r; + r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r; + r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r; + r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r; + r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r; + r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r; + r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_fragment_specular_lighting */ + +#ifdef GL_SGIX_framezoom + +static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_framezoom */ + +#ifdef GL_SGIX_interlace + +#endif /* GL_SGIX_interlace */ + +#ifdef GL_SGIX_ir_instrument1 + +#endif /* GL_SGIX_ir_instrument1 */ + +#ifdef GL_SGIX_list_priority + +#endif /* GL_SGIX_list_priority */ + +#ifdef GL_SGIX_pixel_texture + +static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_pixel_texture */ + +#ifdef GL_SGIX_pixel_texture_bits + +#endif /* GL_SGIX_pixel_texture_bits */ + +#ifdef GL_SGIX_reference_plane + +static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_reference_plane */ + +#ifdef GL_SGIX_resample + +#endif /* GL_SGIX_resample */ + +#ifdef GL_SGIX_shadow + +#endif /* GL_SGIX_shadow */ + +#ifdef GL_SGIX_shadow_ambient + +#endif /* GL_SGIX_shadow_ambient */ + +#ifdef GL_SGIX_sprite + +static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r; + r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r; + r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r; + r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_sprite */ + +#ifdef GL_SGIX_tag_sample_buffer + +static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_tag_sample_buffer */ + +#ifdef GL_SGIX_texture_add_env + +#endif /* GL_SGIX_texture_add_env */ + +#ifdef GL_SGIX_texture_coordinate_clamp + +#endif /* GL_SGIX_texture_coordinate_clamp */ + +#ifdef GL_SGIX_texture_lod_bias + +#endif /* GL_SGIX_texture_lod_bias */ + +#ifdef GL_SGIX_texture_multi_buffer + +#endif /* GL_SGIX_texture_multi_buffer */ + +#ifdef GL_SGIX_texture_range + +#endif /* GL_SGIX_texture_range */ + +#ifdef GL_SGIX_texture_scale_bias + +#endif /* GL_SGIX_texture_scale_bias */ + +#ifdef GL_SGIX_vertex_preclip + +#endif /* GL_SGIX_vertex_preclip */ + +#ifdef GL_SGIX_vertex_preclip_hint + +#endif /* GL_SGIX_vertex_preclip_hint */ + +#ifdef GL_SGIX_ycrcb + +#endif /* GL_SGIX_ycrcb */ + +#ifdef GL_SGI_color_matrix + +#endif /* GL_SGI_color_matrix */ + +#ifdef GL_SGI_color_table + +static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r; + r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r; + r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r; + r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r; + r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r; + r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r; + r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r; + + return r; +} + +#endif /* GL_SGI_color_table */ + +#ifdef GL_SGI_texture_color_table + +#endif /* GL_SGI_texture_color_table */ + +#ifdef GL_SUNX_constant_data + +static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r; + + return r; +} + +#endif /* GL_SUNX_constant_data */ + +#ifdef GL_SUN_convolution_border_modes + +#endif /* GL_SUN_convolution_border_modes */ + +#ifdef GL_SUN_global_alpha + +static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r; + r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r; + r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r; + r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_global_alpha */ + +#ifdef GL_SUN_mesh_array + +#endif /* GL_SUN_mesh_array */ + +#ifdef GL_SUN_read_video_pixels + +static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_read_video_pixels */ + +#ifdef GL_SUN_slice_accum + +#endif /* GL_SUN_slice_accum */ + +#ifdef GL_SUN_triangle_list + +static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r; + r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r; + r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r; + r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r; + r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r; + r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r; + r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_triangle_list */ + +#ifdef GL_SUN_vertex + +static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r; + r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r; + r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r; + r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r; + r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r; + r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r; + r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r; + r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r; + r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r; + r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_vertex */ + +#ifdef GL_WIN_phong_shading + +#endif /* GL_WIN_phong_shading */ + +#ifdef GL_WIN_specular_fog + +#endif /* GL_WIN_specular_fog */ + +#ifdef GL_WIN_swap_hint + +static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r; + + return r; +} + +#endif /* GL_WIN_swap_hint */ + +/* ------------------------------------------------------------------------- */ + +GLboolean glewGetExtension (const char* name) +{ + const GLubyte* start; + const GLubyte* end; + start = (const GLubyte*)glGetString(GL_EXTENSIONS); + if (start == 0) + return GL_FALSE; + end = start + _glewStrLen(start); + return _glewSearchExtension(name, start, end); +} + +/* ------------------------------------------------------------------------- */ + +#ifndef GLEW_MX +static +#endif +GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST) +{ + const GLubyte* s; + GLuint dot; + GLint major, minor; + const GLubyte* extStart; + const GLubyte* extEnd; + /* query opengl version */ + s = glGetString(GL_VERSION); + dot = _glewStrCLen(s, '.'); + if (dot == 0) + return GLEW_ERROR_NO_GL_VERSION; + + major = s[dot-1]-'0'; + minor = s[dot+1]-'0'; + + if (minor < 0 || minor > 9) + minor = 0; + if (major<0 || major>9) + return GLEW_ERROR_NO_GL_VERSION; + + + if (major == 1 && minor == 0) + { + return GLEW_ERROR_GL_VERSION_10_ONLY; + } + else + { + CONST_CAST(GLEW_VERSION_4_2) = ( major > 4 ) || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_4_1) = GLEW_VERSION_4_2 == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_4_0) = GLEW_VERSION_4_1 == GL_TRUE || ( major == 4 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_3_3) = GLEW_VERSION_4_0 == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_3_2) = GLEW_VERSION_3_3 == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_3_1) = GLEW_VERSION_3_2 == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_3_0) = GLEW_VERSION_3_1 == GL_TRUE || ( major == 3 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GLEW_VERSION_3_0 == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_2_0) = GLEW_VERSION_2_1 == GL_TRUE || ( major == 2 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_5) = GLEW_VERSION_2_0 == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_4) = GLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_3) = GLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_2_1) = GLEW_VERSION_1_3 == GL_TRUE ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_2) = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE; + CONST_CAST(GLEW_VERSION_1_1) = GLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE; + } + + /* query opengl extensions string */ + extStart = glGetString(GL_EXTENSIONS); + if (extStart == 0) + extStart = (const GLubyte*)""; + extEnd = extStart + _glewStrLen(extStart); + + /* initialize extensions */ +#ifdef GL_VERSION_1_2 + if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_2 */ +#ifdef GL_VERSION_1_2_1 +#endif /* GL_VERSION_1_2_1 */ +#ifdef GL_VERSION_1_3 + if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_3 */ +#ifdef GL_VERSION_1_4 + if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_4 */ +#ifdef GL_VERSION_1_5 + if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_5 */ +#ifdef GL_VERSION_2_0 + if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_2_0 */ +#ifdef GL_VERSION_2_1 + if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_2_1 */ +#ifdef GL_VERSION_3_0 + if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_3_0 */ +#ifdef GL_VERSION_3_1 + if (glewExperimental || GLEW_VERSION_3_1) CONST_CAST(GLEW_VERSION_3_1) = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_3_1 */ +#ifdef GL_VERSION_3_2 + if (glewExperimental || GLEW_VERSION_3_2) CONST_CAST(GLEW_VERSION_3_2) = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_3_2 */ +#ifdef GL_VERSION_3_3 + if (glewExperimental || GLEW_VERSION_3_3) CONST_CAST(GLEW_VERSION_3_3) = !_glewInit_GL_VERSION_3_3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_3_3 */ +#ifdef GL_VERSION_4_0 + if (glewExperimental || GLEW_VERSION_4_0) CONST_CAST(GLEW_VERSION_4_0) = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_4_0 */ +#ifdef GL_VERSION_4_1 +#endif /* GL_VERSION_4_1 */ +#ifdef GL_VERSION_4_2 +#endif /* GL_VERSION_4_2 */ +#ifdef GL_3DFX_multisample + CONST_CAST(GLEW_3DFX_multisample) = _glewSearchExtension("GL_3DFX_multisample", extStart, extEnd); +#endif /* GL_3DFX_multisample */ +#ifdef GL_3DFX_tbuffer + CONST_CAST(GLEW_3DFX_tbuffer) = _glewSearchExtension("GL_3DFX_tbuffer", extStart, extEnd); + if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_3DFX_tbuffer */ +#ifdef GL_3DFX_texture_compression_FXT1 + CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = _glewSearchExtension("GL_3DFX_texture_compression_FXT1", extStart, extEnd); +#endif /* GL_3DFX_texture_compression_FXT1 */ +#ifdef GL_AMD_blend_minmax_factor + CONST_CAST(GLEW_AMD_blend_minmax_factor) = _glewSearchExtension("GL_AMD_blend_minmax_factor", extStart, extEnd); +#endif /* GL_AMD_blend_minmax_factor */ +#ifdef GL_AMD_conservative_depth + CONST_CAST(GLEW_AMD_conservative_depth) = _glewSearchExtension("GL_AMD_conservative_depth", extStart, extEnd); +#endif /* GL_AMD_conservative_depth */ +#ifdef GL_AMD_debug_output + CONST_CAST(GLEW_AMD_debug_output) = _glewSearchExtension("GL_AMD_debug_output", extStart, extEnd); + if (glewExperimental || GLEW_AMD_debug_output) CONST_CAST(GLEW_AMD_debug_output) = !_glewInit_GL_AMD_debug_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_debug_output */ +#ifdef GL_AMD_depth_clamp_separate + CONST_CAST(GLEW_AMD_depth_clamp_separate) = _glewSearchExtension("GL_AMD_depth_clamp_separate", extStart, extEnd); +#endif /* GL_AMD_depth_clamp_separate */ +#ifdef GL_AMD_draw_buffers_blend + CONST_CAST(GLEW_AMD_draw_buffers_blend) = _glewSearchExtension("GL_AMD_draw_buffers_blend", extStart, extEnd); + if (glewExperimental || GLEW_AMD_draw_buffers_blend) CONST_CAST(GLEW_AMD_draw_buffers_blend) = !_glewInit_GL_AMD_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_multi_draw_indirect + CONST_CAST(GLEW_AMD_multi_draw_indirect) = _glewSearchExtension("GL_AMD_multi_draw_indirect", extStart, extEnd); + if (glewExperimental || GLEW_AMD_multi_draw_indirect) CONST_CAST(GLEW_AMD_multi_draw_indirect) = !_glewInit_GL_AMD_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_multi_draw_indirect */ +#ifdef GL_AMD_name_gen_delete + CONST_CAST(GLEW_AMD_name_gen_delete) = _glewSearchExtension("GL_AMD_name_gen_delete", extStart, extEnd); + if (glewExperimental || GLEW_AMD_name_gen_delete) CONST_CAST(GLEW_AMD_name_gen_delete) = !_glewInit_GL_AMD_name_gen_delete(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_name_gen_delete */ +#ifdef GL_AMD_performance_monitor + CONST_CAST(GLEW_AMD_performance_monitor) = _glewSearchExtension("GL_AMD_performance_monitor", extStart, extEnd); + if (glewExperimental || GLEW_AMD_performance_monitor) CONST_CAST(GLEW_AMD_performance_monitor) = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_performance_monitor */ +#ifdef GL_AMD_sample_positions + CONST_CAST(GLEW_AMD_sample_positions) = _glewSearchExtension("GL_AMD_sample_positions", extStart, extEnd); + if (glewExperimental || GLEW_AMD_sample_positions) CONST_CAST(GLEW_AMD_sample_positions) = !_glewInit_GL_AMD_sample_positions(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_sample_positions */ +#ifdef GL_AMD_seamless_cubemap_per_texture + CONST_CAST(GLEW_AMD_seamless_cubemap_per_texture) = _glewSearchExtension("GL_AMD_seamless_cubemap_per_texture", extStart, extEnd); +#endif /* GL_AMD_seamless_cubemap_per_texture */ +#ifdef GL_AMD_shader_stencil_export + CONST_CAST(GLEW_AMD_shader_stencil_export) = _glewSearchExtension("GL_AMD_shader_stencil_export", extStart, extEnd); +#endif /* GL_AMD_shader_stencil_export */ +#ifdef GL_AMD_texture_texture4 + CONST_CAST(GLEW_AMD_texture_texture4) = _glewSearchExtension("GL_AMD_texture_texture4", extStart, extEnd); +#endif /* GL_AMD_texture_texture4 */ +#ifdef GL_AMD_transform_feedback3_lines_triangles + CONST_CAST(GLEW_AMD_transform_feedback3_lines_triangles) = _glewSearchExtension("GL_AMD_transform_feedback3_lines_triangles", extStart, extEnd); +#endif /* GL_AMD_transform_feedback3_lines_triangles */ +#ifdef GL_AMD_vertex_shader_tessellator + CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = _glewSearchExtension("GL_AMD_vertex_shader_tessellator", extStart, extEnd); + if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = !_glewInit_GL_AMD_vertex_shader_tessellator(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_AMD_vertex_shader_tessellator */ +#ifdef GL_APPLE_aux_depth_stencil + CONST_CAST(GLEW_APPLE_aux_depth_stencil) = _glewSearchExtension("GL_APPLE_aux_depth_stencil", extStart, extEnd); +#endif /* GL_APPLE_aux_depth_stencil */ +#ifdef GL_APPLE_client_storage + CONST_CAST(GLEW_APPLE_client_storage) = _glewSearchExtension("GL_APPLE_client_storage", extStart, extEnd); +#endif /* GL_APPLE_client_storage */ +#ifdef GL_APPLE_element_array + CONST_CAST(GLEW_APPLE_element_array) = _glewSearchExtension("GL_APPLE_element_array", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_element_array */ +#ifdef GL_APPLE_fence + CONST_CAST(GLEW_APPLE_fence) = _glewSearchExtension("GL_APPLE_fence", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_fence */ +#ifdef GL_APPLE_float_pixels + CONST_CAST(GLEW_APPLE_float_pixels) = _glewSearchExtension("GL_APPLE_float_pixels", extStart, extEnd); +#endif /* GL_APPLE_float_pixels */ +#ifdef GL_APPLE_flush_buffer_range + CONST_CAST(GLEW_APPLE_flush_buffer_range) = _glewSearchExtension("GL_APPLE_flush_buffer_range", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_object_purgeable + CONST_CAST(GLEW_APPLE_object_purgeable) = _glewSearchExtension("GL_APPLE_object_purgeable", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_object_purgeable) CONST_CAST(GLEW_APPLE_object_purgeable) = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_object_purgeable */ +#ifdef GL_APPLE_pixel_buffer + CONST_CAST(GLEW_APPLE_pixel_buffer) = _glewSearchExtension("GL_APPLE_pixel_buffer", extStart, extEnd); +#endif /* GL_APPLE_pixel_buffer */ +#ifdef GL_APPLE_rgb_422 + CONST_CAST(GLEW_APPLE_rgb_422) = _glewSearchExtension("GL_APPLE_rgb_422", extStart, extEnd); +#endif /* GL_APPLE_rgb_422 */ +#ifdef GL_APPLE_row_bytes + CONST_CAST(GLEW_APPLE_row_bytes) = _glewSearchExtension("GL_APPLE_row_bytes", extStart, extEnd); +#endif /* GL_APPLE_row_bytes */ +#ifdef GL_APPLE_specular_vector + CONST_CAST(GLEW_APPLE_specular_vector) = _glewSearchExtension("GL_APPLE_specular_vector", extStart, extEnd); +#endif /* GL_APPLE_specular_vector */ +#ifdef GL_APPLE_texture_range + CONST_CAST(GLEW_APPLE_texture_range) = _glewSearchExtension("GL_APPLE_texture_range", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_texture_range */ +#ifdef GL_APPLE_transform_hint + CONST_CAST(GLEW_APPLE_transform_hint) = _glewSearchExtension("GL_APPLE_transform_hint", extStart, extEnd); +#endif /* GL_APPLE_transform_hint */ +#ifdef GL_APPLE_vertex_array_object + CONST_CAST(GLEW_APPLE_vertex_array_object) = _glewSearchExtension("GL_APPLE_vertex_array_object", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_vertex_array_object */ +#ifdef GL_APPLE_vertex_array_range + CONST_CAST(GLEW_APPLE_vertex_array_range) = _glewSearchExtension("GL_APPLE_vertex_array_range", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_vertex_array_range */ +#ifdef GL_APPLE_vertex_program_evaluators + CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = _glewSearchExtension("GL_APPLE_vertex_program_evaluators", extStart, extEnd); + if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = !_glewInit_GL_APPLE_vertex_program_evaluators(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_vertex_program_evaluators */ +#ifdef GL_APPLE_ycbcr_422 + CONST_CAST(GLEW_APPLE_ycbcr_422) = _glewSearchExtension("GL_APPLE_ycbcr_422", extStart, extEnd); +#endif /* GL_APPLE_ycbcr_422 */ +#ifdef GL_ARB_ES2_compatibility + CONST_CAST(GLEW_ARB_ES2_compatibility) = _glewSearchExtension("GL_ARB_ES2_compatibility", extStart, extEnd); + if (glewExperimental || GLEW_ARB_ES2_compatibility) CONST_CAST(GLEW_ARB_ES2_compatibility) = !_glewInit_GL_ARB_ES2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_ES2_compatibility */ +#ifdef GL_ARB_base_instance + CONST_CAST(GLEW_ARB_base_instance) = _glewSearchExtension("GL_ARB_base_instance", extStart, extEnd); + if (glewExperimental || GLEW_ARB_base_instance) CONST_CAST(GLEW_ARB_base_instance) = !_glewInit_GL_ARB_base_instance(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_base_instance */ +#ifdef GL_ARB_blend_func_extended + CONST_CAST(GLEW_ARB_blend_func_extended) = _glewSearchExtension("GL_ARB_blend_func_extended", extStart, extEnd); + if (glewExperimental || GLEW_ARB_blend_func_extended) CONST_CAST(GLEW_ARB_blend_func_extended) = !_glewInit_GL_ARB_blend_func_extended(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_blend_func_extended */ +#ifdef GL_ARB_cl_event + CONST_CAST(GLEW_ARB_cl_event) = _glewSearchExtension("GL_ARB_cl_event", extStart, extEnd); + if (glewExperimental || GLEW_ARB_cl_event) CONST_CAST(GLEW_ARB_cl_event) = !_glewInit_GL_ARB_cl_event(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_cl_event */ +#ifdef GL_ARB_color_buffer_float + CONST_CAST(GLEW_ARB_color_buffer_float) = _glewSearchExtension("GL_ARB_color_buffer_float", extStart, extEnd); + if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_color_buffer_float */ +#ifdef GL_ARB_compatibility + CONST_CAST(GLEW_ARB_compatibility) = _glewSearchExtension("GL_ARB_compatibility", extStart, extEnd); +#endif /* GL_ARB_compatibility */ +#ifdef GL_ARB_compressed_texture_pixel_storage + CONST_CAST(GLEW_ARB_compressed_texture_pixel_storage) = _glewSearchExtension("GL_ARB_compressed_texture_pixel_storage", extStart, extEnd); +#endif /* GL_ARB_compressed_texture_pixel_storage */ +#ifdef GL_ARB_conservative_depth + CONST_CAST(GLEW_ARB_conservative_depth) = _glewSearchExtension("GL_ARB_conservative_depth", extStart, extEnd); +#endif /* GL_ARB_conservative_depth */ +#ifdef GL_ARB_copy_buffer + CONST_CAST(GLEW_ARB_copy_buffer) = _glewSearchExtension("GL_ARB_copy_buffer", extStart, extEnd); + if (glewExperimental || GLEW_ARB_copy_buffer) CONST_CAST(GLEW_ARB_copy_buffer) = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_copy_buffer */ +#ifdef GL_ARB_debug_output + CONST_CAST(GLEW_ARB_debug_output) = _glewSearchExtension("GL_ARB_debug_output", extStart, extEnd); + if (glewExperimental || GLEW_ARB_debug_output) CONST_CAST(GLEW_ARB_debug_output) = !_glewInit_GL_ARB_debug_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_debug_output */ +#ifdef GL_ARB_depth_buffer_float + CONST_CAST(GLEW_ARB_depth_buffer_float) = _glewSearchExtension("GL_ARB_depth_buffer_float", extStart, extEnd); +#endif /* GL_ARB_depth_buffer_float */ +#ifdef GL_ARB_depth_clamp + CONST_CAST(GLEW_ARB_depth_clamp) = _glewSearchExtension("GL_ARB_depth_clamp", extStart, extEnd); +#endif /* GL_ARB_depth_clamp */ +#ifdef GL_ARB_depth_texture + CONST_CAST(GLEW_ARB_depth_texture) = _glewSearchExtension("GL_ARB_depth_texture", extStart, extEnd); +#endif /* GL_ARB_depth_texture */ +#ifdef GL_ARB_draw_buffers + CONST_CAST(GLEW_ARB_draw_buffers) = _glewSearchExtension("GL_ARB_draw_buffers", extStart, extEnd); + if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_buffers */ +#ifdef GL_ARB_draw_buffers_blend + CONST_CAST(GLEW_ARB_draw_buffers_blend) = _glewSearchExtension("GL_ARB_draw_buffers_blend", extStart, extEnd); + if (glewExperimental || GLEW_ARB_draw_buffers_blend) CONST_CAST(GLEW_ARB_draw_buffers_blend) = !_glewInit_GL_ARB_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_buffers_blend */ +#ifdef GL_ARB_draw_elements_base_vertex + CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = _glewSearchExtension("GL_ARB_draw_elements_base_vertex", extStart, extEnd); + if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = !_glewInit_GL_ARB_draw_elements_base_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_elements_base_vertex */ +#ifdef GL_ARB_draw_indirect + CONST_CAST(GLEW_ARB_draw_indirect) = _glewSearchExtension("GL_ARB_draw_indirect", extStart, extEnd); + if (glewExperimental || GLEW_ARB_draw_indirect) CONST_CAST(GLEW_ARB_draw_indirect) = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_indirect */ +#ifdef GL_ARB_draw_instanced + CONST_CAST(GLEW_ARB_draw_instanced) = _glewSearchExtension("GL_ARB_draw_instanced", extStart, extEnd); +#endif /* GL_ARB_draw_instanced */ +#ifdef GL_ARB_explicit_attrib_location + CONST_CAST(GLEW_ARB_explicit_attrib_location) = _glewSearchExtension("GL_ARB_explicit_attrib_location", extStart, extEnd); +#endif /* GL_ARB_explicit_attrib_location */ +#ifdef GL_ARB_fragment_coord_conventions + CONST_CAST(GLEW_ARB_fragment_coord_conventions) = _glewSearchExtension("GL_ARB_fragment_coord_conventions", extStart, extEnd); +#endif /* GL_ARB_fragment_coord_conventions */ +#ifdef GL_ARB_fragment_program + CONST_CAST(GLEW_ARB_fragment_program) = _glewSearchExtension("GL_ARB_fragment_program", extStart, extEnd); +#endif /* GL_ARB_fragment_program */ +#ifdef GL_ARB_fragment_program_shadow + CONST_CAST(GLEW_ARB_fragment_program_shadow) = _glewSearchExtension("GL_ARB_fragment_program_shadow", extStart, extEnd); +#endif /* GL_ARB_fragment_program_shadow */ +#ifdef GL_ARB_fragment_shader + CONST_CAST(GLEW_ARB_fragment_shader) = _glewSearchExtension("GL_ARB_fragment_shader", extStart, extEnd); +#endif /* GL_ARB_fragment_shader */ +#ifdef GL_ARB_framebuffer_object + CONST_CAST(GLEW_ARB_framebuffer_object) = _glewSearchExtension("GL_ARB_framebuffer_object", extStart, extEnd); + if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_framebuffer_object */ +#ifdef GL_ARB_framebuffer_sRGB + CONST_CAST(GLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GL_ARB_framebuffer_sRGB", extStart, extEnd); +#endif /* GL_ARB_framebuffer_sRGB */ +#ifdef GL_ARB_geometry_shader4 + CONST_CAST(GLEW_ARB_geometry_shader4) = _glewSearchExtension("GL_ARB_geometry_shader4", extStart, extEnd); + if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_geometry_shader4 */ +#ifdef GL_ARB_get_program_binary + CONST_CAST(GLEW_ARB_get_program_binary) = _glewSearchExtension("GL_ARB_get_program_binary", extStart, extEnd); + if (glewExperimental || GLEW_ARB_get_program_binary) CONST_CAST(GLEW_ARB_get_program_binary) = !_glewInit_GL_ARB_get_program_binary(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_get_program_binary */ +#ifdef GL_ARB_gpu_shader5 + CONST_CAST(GLEW_ARB_gpu_shader5) = _glewSearchExtension("GL_ARB_gpu_shader5", extStart, extEnd); +#endif /* GL_ARB_gpu_shader5 */ +#ifdef GL_ARB_gpu_shader_fp64 + CONST_CAST(GLEW_ARB_gpu_shader_fp64) = _glewSearchExtension("GL_ARB_gpu_shader_fp64", extStart, extEnd); + if (glewExperimental || GLEW_ARB_gpu_shader_fp64) CONST_CAST(GLEW_ARB_gpu_shader_fp64) = !_glewInit_GL_ARB_gpu_shader_fp64(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_gpu_shader_fp64 */ +#ifdef GL_ARB_half_float_pixel + CONST_CAST(GLEW_ARB_half_float_pixel) = _glewSearchExtension("GL_ARB_half_float_pixel", extStart, extEnd); +#endif /* GL_ARB_half_float_pixel */ +#ifdef GL_ARB_half_float_vertex + CONST_CAST(GLEW_ARB_half_float_vertex) = _glewSearchExtension("GL_ARB_half_float_vertex", extStart, extEnd); +#endif /* GL_ARB_half_float_vertex */ +#ifdef GL_ARB_imaging + CONST_CAST(GLEW_ARB_imaging) = _glewSearchExtension("GL_ARB_imaging", extStart, extEnd); + if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_imaging */ +#ifdef GL_ARB_instanced_arrays + CONST_CAST(GLEW_ARB_instanced_arrays) = _glewSearchExtension("GL_ARB_instanced_arrays", extStart, extEnd); + if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_instanced_arrays */ +#ifdef GL_ARB_internalformat_query + CONST_CAST(GLEW_ARB_internalformat_query) = _glewSearchExtension("GL_ARB_internalformat_query", extStart, extEnd); + if (glewExperimental || GLEW_ARB_internalformat_query) CONST_CAST(GLEW_ARB_internalformat_query) = !_glewInit_GL_ARB_internalformat_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_internalformat_query */ +#ifdef GL_ARB_map_buffer_alignment + CONST_CAST(GLEW_ARB_map_buffer_alignment) = _glewSearchExtension("GL_ARB_map_buffer_alignment", extStart, extEnd); +#endif /* GL_ARB_map_buffer_alignment */ +#ifdef GL_ARB_map_buffer_range + CONST_CAST(GLEW_ARB_map_buffer_range) = _glewSearchExtension("GL_ARB_map_buffer_range", extStart, extEnd); + if (glewExperimental || GLEW_ARB_map_buffer_range) CONST_CAST(GLEW_ARB_map_buffer_range) = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_map_buffer_range */ +#ifdef GL_ARB_matrix_palette + CONST_CAST(GLEW_ARB_matrix_palette) = _glewSearchExtension("GL_ARB_matrix_palette", extStart, extEnd); + if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_matrix_palette */ +#ifdef GL_ARB_multisample + CONST_CAST(GLEW_ARB_multisample) = _glewSearchExtension("GL_ARB_multisample", extStart, extEnd); + if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_multisample */ +#ifdef GL_ARB_multitexture + CONST_CAST(GLEW_ARB_multitexture) = _glewSearchExtension("GL_ARB_multitexture", extStart, extEnd); + if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_multitexture */ +#ifdef GL_ARB_occlusion_query + CONST_CAST(GLEW_ARB_occlusion_query) = _glewSearchExtension("GL_ARB_occlusion_query", extStart, extEnd); + if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_occlusion_query */ +#ifdef GL_ARB_occlusion_query2 + CONST_CAST(GLEW_ARB_occlusion_query2) = _glewSearchExtension("GL_ARB_occlusion_query2", extStart, extEnd); +#endif /* GL_ARB_occlusion_query2 */ +#ifdef GL_ARB_pixel_buffer_object + CONST_CAST(GLEW_ARB_pixel_buffer_object) = _glewSearchExtension("GL_ARB_pixel_buffer_object", extStart, extEnd); +#endif /* GL_ARB_pixel_buffer_object */ +#ifdef GL_ARB_point_parameters + CONST_CAST(GLEW_ARB_point_parameters) = _glewSearchExtension("GL_ARB_point_parameters", extStart, extEnd); + if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_point_parameters */ +#ifdef GL_ARB_point_sprite + CONST_CAST(GLEW_ARB_point_sprite) = _glewSearchExtension("GL_ARB_point_sprite", extStart, extEnd); +#endif /* GL_ARB_point_sprite */ +#ifdef GL_ARB_provoking_vertex + CONST_CAST(GLEW_ARB_provoking_vertex) = _glewSearchExtension("GL_ARB_provoking_vertex", extStart, extEnd); + if (glewExperimental || GLEW_ARB_provoking_vertex) CONST_CAST(GLEW_ARB_provoking_vertex) = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_provoking_vertex */ +#ifdef GL_ARB_robustness + CONST_CAST(GLEW_ARB_robustness) = _glewSearchExtension("GL_ARB_robustness", extStart, extEnd); + if (glewExperimental || GLEW_ARB_robustness) CONST_CAST(GLEW_ARB_robustness) = !_glewInit_GL_ARB_robustness(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_robustness */ +#ifdef GL_ARB_sample_shading + CONST_CAST(GLEW_ARB_sample_shading) = _glewSearchExtension("GL_ARB_sample_shading", extStart, extEnd); + if (glewExperimental || GLEW_ARB_sample_shading) CONST_CAST(GLEW_ARB_sample_shading) = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_sample_shading */ +#ifdef GL_ARB_sampler_objects + CONST_CAST(GLEW_ARB_sampler_objects) = _glewSearchExtension("GL_ARB_sampler_objects", extStart, extEnd); + if (glewExperimental || GLEW_ARB_sampler_objects) CONST_CAST(GLEW_ARB_sampler_objects) = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_sampler_objects */ +#ifdef GL_ARB_seamless_cube_map + CONST_CAST(GLEW_ARB_seamless_cube_map) = _glewSearchExtension("GL_ARB_seamless_cube_map", extStart, extEnd); +#endif /* GL_ARB_seamless_cube_map */ +#ifdef GL_ARB_separate_shader_objects + CONST_CAST(GLEW_ARB_separate_shader_objects) = _glewSearchExtension("GL_ARB_separate_shader_objects", extStart, extEnd); + if (glewExperimental || GLEW_ARB_separate_shader_objects) CONST_CAST(GLEW_ARB_separate_shader_objects) = !_glewInit_GL_ARB_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_separate_shader_objects */ +#ifdef GL_ARB_shader_atomic_counters + CONST_CAST(GLEW_ARB_shader_atomic_counters) = _glewSearchExtension("GL_ARB_shader_atomic_counters", extStart, extEnd); + if (glewExperimental || GLEW_ARB_shader_atomic_counters) CONST_CAST(GLEW_ARB_shader_atomic_counters) = !_glewInit_GL_ARB_shader_atomic_counters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shader_atomic_counters */ +#ifdef GL_ARB_shader_bit_encoding + CONST_CAST(GLEW_ARB_shader_bit_encoding) = _glewSearchExtension("GL_ARB_shader_bit_encoding", extStart, extEnd); +#endif /* GL_ARB_shader_bit_encoding */ +#ifdef GL_ARB_shader_image_load_store + CONST_CAST(GLEW_ARB_shader_image_load_store) = _glewSearchExtension("GL_ARB_shader_image_load_store", extStart, extEnd); + if (glewExperimental || GLEW_ARB_shader_image_load_store) CONST_CAST(GLEW_ARB_shader_image_load_store) = !_glewInit_GL_ARB_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shader_image_load_store */ +#ifdef GL_ARB_shader_objects + CONST_CAST(GLEW_ARB_shader_objects) = _glewSearchExtension("GL_ARB_shader_objects", extStart, extEnd); + if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shader_objects */ +#ifdef GL_ARB_shader_precision + CONST_CAST(GLEW_ARB_shader_precision) = _glewSearchExtension("GL_ARB_shader_precision", extStart, extEnd); +#endif /* GL_ARB_shader_precision */ +#ifdef GL_ARB_shader_stencil_export + CONST_CAST(GLEW_ARB_shader_stencil_export) = _glewSearchExtension("GL_ARB_shader_stencil_export", extStart, extEnd); +#endif /* GL_ARB_shader_stencil_export */ +#ifdef GL_ARB_shader_subroutine + CONST_CAST(GLEW_ARB_shader_subroutine) = _glewSearchExtension("GL_ARB_shader_subroutine", extStart, extEnd); + if (glewExperimental || GLEW_ARB_shader_subroutine) CONST_CAST(GLEW_ARB_shader_subroutine) = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shader_subroutine */ +#ifdef GL_ARB_shader_texture_lod + CONST_CAST(GLEW_ARB_shader_texture_lod) = _glewSearchExtension("GL_ARB_shader_texture_lod", extStart, extEnd); +#endif /* GL_ARB_shader_texture_lod */ +#ifdef GL_ARB_shading_language_100 + CONST_CAST(GLEW_ARB_shading_language_100) = _glewSearchExtension("GL_ARB_shading_language_100", extStart, extEnd); +#endif /* GL_ARB_shading_language_100 */ +#ifdef GL_ARB_shading_language_420pack + CONST_CAST(GLEW_ARB_shading_language_420pack) = _glewSearchExtension("GL_ARB_shading_language_420pack", extStart, extEnd); +#endif /* GL_ARB_shading_language_420pack */ +#ifdef GL_ARB_shading_language_include + CONST_CAST(GLEW_ARB_shading_language_include) = _glewSearchExtension("GL_ARB_shading_language_include", extStart, extEnd); + if (glewExperimental || GLEW_ARB_shading_language_include) CONST_CAST(GLEW_ARB_shading_language_include) = !_glewInit_GL_ARB_shading_language_include(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shading_language_include */ +#ifdef GL_ARB_shading_language_packing + CONST_CAST(GLEW_ARB_shading_language_packing) = _glewSearchExtension("GL_ARB_shading_language_packing", extStart, extEnd); +#endif /* GL_ARB_shading_language_packing */ +#ifdef GL_ARB_shadow + CONST_CAST(GLEW_ARB_shadow) = _glewSearchExtension("GL_ARB_shadow", extStart, extEnd); +#endif /* GL_ARB_shadow */ +#ifdef GL_ARB_shadow_ambient + CONST_CAST(GLEW_ARB_shadow_ambient) = _glewSearchExtension("GL_ARB_shadow_ambient", extStart, extEnd); +#endif /* GL_ARB_shadow_ambient */ +#ifdef GL_ARB_sync + CONST_CAST(GLEW_ARB_sync) = _glewSearchExtension("GL_ARB_sync", extStart, extEnd); + if (glewExperimental || GLEW_ARB_sync) CONST_CAST(GLEW_ARB_sync) = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_sync */ +#ifdef GL_ARB_tessellation_shader + CONST_CAST(GLEW_ARB_tessellation_shader) = _glewSearchExtension("GL_ARB_tessellation_shader", extStart, extEnd); + if (glewExperimental || GLEW_ARB_tessellation_shader) CONST_CAST(GLEW_ARB_tessellation_shader) = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_tessellation_shader */ +#ifdef GL_ARB_texture_border_clamp + CONST_CAST(GLEW_ARB_texture_border_clamp) = _glewSearchExtension("GL_ARB_texture_border_clamp", extStart, extEnd); +#endif /* GL_ARB_texture_border_clamp */ +#ifdef GL_ARB_texture_buffer_object + CONST_CAST(GLEW_ARB_texture_buffer_object) = _glewSearchExtension("GL_ARB_texture_buffer_object", extStart, extEnd); + if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_buffer_object */ +#ifdef GL_ARB_texture_buffer_object_rgb32 + CONST_CAST(GLEW_ARB_texture_buffer_object_rgb32) = _glewSearchExtension("GL_ARB_texture_buffer_object_rgb32", extStart, extEnd); +#endif /* GL_ARB_texture_buffer_object_rgb32 */ +#ifdef GL_ARB_texture_compression + CONST_CAST(GLEW_ARB_texture_compression) = _glewSearchExtension("GL_ARB_texture_compression", extStart, extEnd); + if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_compression */ +#ifdef GL_ARB_texture_compression_bptc + CONST_CAST(GLEW_ARB_texture_compression_bptc) = _glewSearchExtension("GL_ARB_texture_compression_bptc", extStart, extEnd); +#endif /* GL_ARB_texture_compression_bptc */ +#ifdef GL_ARB_texture_compression_rgtc + CONST_CAST(GLEW_ARB_texture_compression_rgtc) = _glewSearchExtension("GL_ARB_texture_compression_rgtc", extStart, extEnd); +#endif /* GL_ARB_texture_compression_rgtc */ +#ifdef GL_ARB_texture_cube_map + CONST_CAST(GLEW_ARB_texture_cube_map) = _glewSearchExtension("GL_ARB_texture_cube_map", extStart, extEnd); +#endif /* GL_ARB_texture_cube_map */ +#ifdef GL_ARB_texture_cube_map_array + CONST_CAST(GLEW_ARB_texture_cube_map_array) = _glewSearchExtension("GL_ARB_texture_cube_map_array", extStart, extEnd); +#endif /* GL_ARB_texture_cube_map_array */ +#ifdef GL_ARB_texture_env_add + CONST_CAST(GLEW_ARB_texture_env_add) = _glewSearchExtension("GL_ARB_texture_env_add", extStart, extEnd); +#endif /* GL_ARB_texture_env_add */ +#ifdef GL_ARB_texture_env_combine + CONST_CAST(GLEW_ARB_texture_env_combine) = _glewSearchExtension("GL_ARB_texture_env_combine", extStart, extEnd); +#endif /* GL_ARB_texture_env_combine */ +#ifdef GL_ARB_texture_env_crossbar + CONST_CAST(GLEW_ARB_texture_env_crossbar) = _glewSearchExtension("GL_ARB_texture_env_crossbar", extStart, extEnd); +#endif /* GL_ARB_texture_env_crossbar */ +#ifdef GL_ARB_texture_env_dot3 + CONST_CAST(GLEW_ARB_texture_env_dot3) = _glewSearchExtension("GL_ARB_texture_env_dot3", extStart, extEnd); +#endif /* GL_ARB_texture_env_dot3 */ +#ifdef GL_ARB_texture_float + CONST_CAST(GLEW_ARB_texture_float) = _glewSearchExtension("GL_ARB_texture_float", extStart, extEnd); +#endif /* GL_ARB_texture_float */ +#ifdef GL_ARB_texture_gather + CONST_CAST(GLEW_ARB_texture_gather) = _glewSearchExtension("GL_ARB_texture_gather", extStart, extEnd); +#endif /* GL_ARB_texture_gather */ +#ifdef GL_ARB_texture_mirrored_repeat + CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = _glewSearchExtension("GL_ARB_texture_mirrored_repeat", extStart, extEnd); +#endif /* GL_ARB_texture_mirrored_repeat */ +#ifdef GL_ARB_texture_multisample + CONST_CAST(GLEW_ARB_texture_multisample) = _glewSearchExtension("GL_ARB_texture_multisample", extStart, extEnd); + if (glewExperimental || GLEW_ARB_texture_multisample) CONST_CAST(GLEW_ARB_texture_multisample) = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_multisample */ +#ifdef GL_ARB_texture_non_power_of_two + CONST_CAST(GLEW_ARB_texture_non_power_of_two) = _glewSearchExtension("GL_ARB_texture_non_power_of_two", extStart, extEnd); +#endif /* GL_ARB_texture_non_power_of_two */ +#ifdef GL_ARB_texture_query_lod + CONST_CAST(GLEW_ARB_texture_query_lod) = _glewSearchExtension("GL_ARB_texture_query_lod", extStart, extEnd); +#endif /* GL_ARB_texture_query_lod */ +#ifdef GL_ARB_texture_rectangle + CONST_CAST(GLEW_ARB_texture_rectangle) = _glewSearchExtension("GL_ARB_texture_rectangle", extStart, extEnd); +#endif /* GL_ARB_texture_rectangle */ +#ifdef GL_ARB_texture_rg + CONST_CAST(GLEW_ARB_texture_rg) = _glewSearchExtension("GL_ARB_texture_rg", extStart, extEnd); +#endif /* GL_ARB_texture_rg */ +#ifdef GL_ARB_texture_rgb10_a2ui + CONST_CAST(GLEW_ARB_texture_rgb10_a2ui) = _glewSearchExtension("GL_ARB_texture_rgb10_a2ui", extStart, extEnd); +#endif /* GL_ARB_texture_rgb10_a2ui */ +#ifdef GL_ARB_texture_storage + CONST_CAST(GLEW_ARB_texture_storage) = _glewSearchExtension("GL_ARB_texture_storage", extStart, extEnd); + if (glewExperimental || GLEW_ARB_texture_storage) CONST_CAST(GLEW_ARB_texture_storage) = !_glewInit_GL_ARB_texture_storage(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_storage */ +#ifdef GL_ARB_texture_swizzle + CONST_CAST(GLEW_ARB_texture_swizzle) = _glewSearchExtension("GL_ARB_texture_swizzle", extStart, extEnd); +#endif /* GL_ARB_texture_swizzle */ +#ifdef GL_ARB_timer_query + CONST_CAST(GLEW_ARB_timer_query) = _glewSearchExtension("GL_ARB_timer_query", extStart, extEnd); + if (glewExperimental || GLEW_ARB_timer_query) CONST_CAST(GLEW_ARB_timer_query) = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_timer_query */ +#ifdef GL_ARB_transform_feedback2 + CONST_CAST(GLEW_ARB_transform_feedback2) = _glewSearchExtension("GL_ARB_transform_feedback2", extStart, extEnd); + if (glewExperimental || GLEW_ARB_transform_feedback2) CONST_CAST(GLEW_ARB_transform_feedback2) = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_transform_feedback2 */ +#ifdef GL_ARB_transform_feedback3 + CONST_CAST(GLEW_ARB_transform_feedback3) = _glewSearchExtension("GL_ARB_transform_feedback3", extStart, extEnd); + if (glewExperimental || GLEW_ARB_transform_feedback3) CONST_CAST(GLEW_ARB_transform_feedback3) = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_transform_feedback3 */ +#ifdef GL_ARB_transform_feedback_instanced + CONST_CAST(GLEW_ARB_transform_feedback_instanced) = _glewSearchExtension("GL_ARB_transform_feedback_instanced", extStart, extEnd); + if (glewExperimental || GLEW_ARB_transform_feedback_instanced) CONST_CAST(GLEW_ARB_transform_feedback_instanced) = !_glewInit_GL_ARB_transform_feedback_instanced(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_transform_feedback_instanced */ +#ifdef GL_ARB_transpose_matrix + CONST_CAST(GLEW_ARB_transpose_matrix) = _glewSearchExtension("GL_ARB_transpose_matrix", extStart, extEnd); + if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_transpose_matrix */ +#ifdef GL_ARB_uniform_buffer_object + CONST_CAST(GLEW_ARB_uniform_buffer_object) = _glewSearchExtension("GL_ARB_uniform_buffer_object", extStart, extEnd); + if (glewExperimental || GLEW_ARB_uniform_buffer_object) CONST_CAST(GLEW_ARB_uniform_buffer_object) = !_glewInit_GL_ARB_uniform_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_uniform_buffer_object */ +#ifdef GL_ARB_vertex_array_bgra + CONST_CAST(GLEW_ARB_vertex_array_bgra) = _glewSearchExtension("GL_ARB_vertex_array_bgra", extStart, extEnd); +#endif /* GL_ARB_vertex_array_bgra */ +#ifdef GL_ARB_vertex_array_object + CONST_CAST(GLEW_ARB_vertex_array_object) = _glewSearchExtension("GL_ARB_vertex_array_object", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_array_object */ +#ifdef GL_ARB_vertex_attrib_64bit + CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = _glewSearchExtension("GL_ARB_vertex_attrib_64bit", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_attrib_64bit) CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = !_glewInit_GL_ARB_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_attrib_64bit */ +#ifdef GL_ARB_vertex_blend + CONST_CAST(GLEW_ARB_vertex_blend) = _glewSearchExtension("GL_ARB_vertex_blend", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_blend */ +#ifdef GL_ARB_vertex_buffer_object + CONST_CAST(GLEW_ARB_vertex_buffer_object) = _glewSearchExtension("GL_ARB_vertex_buffer_object", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_buffer_object */ +#ifdef GL_ARB_vertex_program + CONST_CAST(GLEW_ARB_vertex_program) = _glewSearchExtension("GL_ARB_vertex_program", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_program */ +#ifdef GL_ARB_vertex_shader + CONST_CAST(GLEW_ARB_vertex_shader) = _glewSearchExtension("GL_ARB_vertex_shader", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_shader */ +#ifdef GL_ARB_vertex_type_2_10_10_10_rev + CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = _glewSearchExtension("GL_ARB_vertex_type_2_10_10_10_rev", extStart, extEnd); + if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_type_2_10_10_10_rev */ +#ifdef GL_ARB_viewport_array + CONST_CAST(GLEW_ARB_viewport_array) = _glewSearchExtension("GL_ARB_viewport_array", extStart, extEnd); + if (glewExperimental || GLEW_ARB_viewport_array) CONST_CAST(GLEW_ARB_viewport_array) = !_glewInit_GL_ARB_viewport_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_viewport_array */ +#ifdef GL_ARB_window_pos + CONST_CAST(GLEW_ARB_window_pos) = _glewSearchExtension("GL_ARB_window_pos", extStart, extEnd); + if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_window_pos */ +#ifdef GL_ATIX_point_sprites + CONST_CAST(GLEW_ATIX_point_sprites) = _glewSearchExtension("GL_ATIX_point_sprites", extStart, extEnd); +#endif /* GL_ATIX_point_sprites */ +#ifdef GL_ATIX_texture_env_combine3 + CONST_CAST(GLEW_ATIX_texture_env_combine3) = _glewSearchExtension("GL_ATIX_texture_env_combine3", extStart, extEnd); +#endif /* GL_ATIX_texture_env_combine3 */ +#ifdef GL_ATIX_texture_env_route + CONST_CAST(GLEW_ATIX_texture_env_route) = _glewSearchExtension("GL_ATIX_texture_env_route", extStart, extEnd); +#endif /* GL_ATIX_texture_env_route */ +#ifdef GL_ATIX_vertex_shader_output_point_size + CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = _glewSearchExtension("GL_ATIX_vertex_shader_output_point_size", extStart, extEnd); +#endif /* GL_ATIX_vertex_shader_output_point_size */ +#ifdef GL_ATI_draw_buffers + CONST_CAST(GLEW_ATI_draw_buffers) = _glewSearchExtension("GL_ATI_draw_buffers", extStart, extEnd); + if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_draw_buffers */ +#ifdef GL_ATI_element_array + CONST_CAST(GLEW_ATI_element_array) = _glewSearchExtension("GL_ATI_element_array", extStart, extEnd); + if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_element_array */ +#ifdef GL_ATI_envmap_bumpmap + CONST_CAST(GLEW_ATI_envmap_bumpmap) = _glewSearchExtension("GL_ATI_envmap_bumpmap", extStart, extEnd); + if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_envmap_bumpmap */ +#ifdef GL_ATI_fragment_shader + CONST_CAST(GLEW_ATI_fragment_shader) = _glewSearchExtension("GL_ATI_fragment_shader", extStart, extEnd); + if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_fragment_shader */ +#ifdef GL_ATI_map_object_buffer + CONST_CAST(GLEW_ATI_map_object_buffer) = _glewSearchExtension("GL_ATI_map_object_buffer", extStart, extEnd); + if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_map_object_buffer */ +#ifdef GL_ATI_meminfo + CONST_CAST(GLEW_ATI_meminfo) = _glewSearchExtension("GL_ATI_meminfo", extStart, extEnd); +#endif /* GL_ATI_meminfo */ +#ifdef GL_ATI_pn_triangles + CONST_CAST(GLEW_ATI_pn_triangles) = _glewSearchExtension("GL_ATI_pn_triangles", extStart, extEnd); + if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_pn_triangles */ +#ifdef GL_ATI_separate_stencil + CONST_CAST(GLEW_ATI_separate_stencil) = _glewSearchExtension("GL_ATI_separate_stencil", extStart, extEnd); + if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_separate_stencil */ +#ifdef GL_ATI_shader_texture_lod + CONST_CAST(GLEW_ATI_shader_texture_lod) = _glewSearchExtension("GL_ATI_shader_texture_lod", extStart, extEnd); +#endif /* GL_ATI_shader_texture_lod */ +#ifdef GL_ATI_text_fragment_shader + CONST_CAST(GLEW_ATI_text_fragment_shader) = _glewSearchExtension("GL_ATI_text_fragment_shader", extStart, extEnd); +#endif /* GL_ATI_text_fragment_shader */ +#ifdef GL_ATI_texture_compression_3dc + CONST_CAST(GLEW_ATI_texture_compression_3dc) = _glewSearchExtension("GL_ATI_texture_compression_3dc", extStart, extEnd); +#endif /* GL_ATI_texture_compression_3dc */ +#ifdef GL_ATI_texture_env_combine3 + CONST_CAST(GLEW_ATI_texture_env_combine3) = _glewSearchExtension("GL_ATI_texture_env_combine3", extStart, extEnd); +#endif /* GL_ATI_texture_env_combine3 */ +#ifdef GL_ATI_texture_float + CONST_CAST(GLEW_ATI_texture_float) = _glewSearchExtension("GL_ATI_texture_float", extStart, extEnd); +#endif /* GL_ATI_texture_float */ +#ifdef GL_ATI_texture_mirror_once + CONST_CAST(GLEW_ATI_texture_mirror_once) = _glewSearchExtension("GL_ATI_texture_mirror_once", extStart, extEnd); +#endif /* GL_ATI_texture_mirror_once */ +#ifdef GL_ATI_vertex_array_object + CONST_CAST(GLEW_ATI_vertex_array_object) = _glewSearchExtension("GL_ATI_vertex_array_object", extStart, extEnd); + if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_array_object */ +#ifdef GL_ATI_vertex_attrib_array_object + CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = _glewSearchExtension("GL_ATI_vertex_attrib_array_object", extStart, extEnd); + if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_attrib_array_object */ +#ifdef GL_ATI_vertex_streams + CONST_CAST(GLEW_ATI_vertex_streams) = _glewSearchExtension("GL_ATI_vertex_streams", extStart, extEnd); + if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_streams */ +#ifdef GL_EXT_422_pixels + CONST_CAST(GLEW_EXT_422_pixels) = _glewSearchExtension("GL_EXT_422_pixels", extStart, extEnd); +#endif /* GL_EXT_422_pixels */ +#ifdef GL_EXT_Cg_shader + CONST_CAST(GLEW_EXT_Cg_shader) = _glewSearchExtension("GL_EXT_Cg_shader", extStart, extEnd); +#endif /* GL_EXT_Cg_shader */ +#ifdef GL_EXT_abgr + CONST_CAST(GLEW_EXT_abgr) = _glewSearchExtension("GL_EXT_abgr", extStart, extEnd); +#endif /* GL_EXT_abgr */ +#ifdef GL_EXT_bgra + CONST_CAST(GLEW_EXT_bgra) = _glewSearchExtension("GL_EXT_bgra", extStart, extEnd); +#endif /* GL_EXT_bgra */ +#ifdef GL_EXT_bindable_uniform + CONST_CAST(GLEW_EXT_bindable_uniform) = _glewSearchExtension("GL_EXT_bindable_uniform", extStart, extEnd); + if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_bindable_uniform */ +#ifdef GL_EXT_blend_color + CONST_CAST(GLEW_EXT_blend_color) = _glewSearchExtension("GL_EXT_blend_color", extStart, extEnd); + if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_color */ +#ifdef GL_EXT_blend_equation_separate + CONST_CAST(GLEW_EXT_blend_equation_separate) = _glewSearchExtension("GL_EXT_blend_equation_separate", extStart, extEnd); + if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_separate + CONST_CAST(GLEW_EXT_blend_func_separate) = _glewSearchExtension("GL_EXT_blend_func_separate", extStart, extEnd); + if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_func_separate */ +#ifdef GL_EXT_blend_logic_op + CONST_CAST(GLEW_EXT_blend_logic_op) = _glewSearchExtension("GL_EXT_blend_logic_op", extStart, extEnd); +#endif /* GL_EXT_blend_logic_op */ +#ifdef GL_EXT_blend_minmax + CONST_CAST(GLEW_EXT_blend_minmax) = _glewSearchExtension("GL_EXT_blend_minmax", extStart, extEnd); + if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_minmax */ +#ifdef GL_EXT_blend_subtract + CONST_CAST(GLEW_EXT_blend_subtract) = _glewSearchExtension("GL_EXT_blend_subtract", extStart, extEnd); +#endif /* GL_EXT_blend_subtract */ +#ifdef GL_EXT_clip_volume_hint + CONST_CAST(GLEW_EXT_clip_volume_hint) = _glewSearchExtension("GL_EXT_clip_volume_hint", extStart, extEnd); +#endif /* GL_EXT_clip_volume_hint */ +#ifdef GL_EXT_cmyka + CONST_CAST(GLEW_EXT_cmyka) = _glewSearchExtension("GL_EXT_cmyka", extStart, extEnd); +#endif /* GL_EXT_cmyka */ +#ifdef GL_EXT_color_subtable + CONST_CAST(GLEW_EXT_color_subtable) = _glewSearchExtension("GL_EXT_color_subtable", extStart, extEnd); + if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_color_subtable */ +#ifdef GL_EXT_compiled_vertex_array + CONST_CAST(GLEW_EXT_compiled_vertex_array) = _glewSearchExtension("GL_EXT_compiled_vertex_array", extStart, extEnd); + if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_convolution + CONST_CAST(GLEW_EXT_convolution) = _glewSearchExtension("GL_EXT_convolution", extStart, extEnd); + if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_convolution */ +#ifdef GL_EXT_coordinate_frame + CONST_CAST(GLEW_EXT_coordinate_frame) = _glewSearchExtension("GL_EXT_coordinate_frame", extStart, extEnd); + if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_texture + CONST_CAST(GLEW_EXT_copy_texture) = _glewSearchExtension("GL_EXT_copy_texture", extStart, extEnd); + if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_copy_texture */ +#ifdef GL_EXT_cull_vertex + CONST_CAST(GLEW_EXT_cull_vertex) = _glewSearchExtension("GL_EXT_cull_vertex", extStart, extEnd); + if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_cull_vertex */ +#ifdef GL_EXT_depth_bounds_test + CONST_CAST(GLEW_EXT_depth_bounds_test) = _glewSearchExtension("GL_EXT_depth_bounds_test", extStart, extEnd); + if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_depth_bounds_test */ +#ifdef GL_EXT_direct_state_access + CONST_CAST(GLEW_EXT_direct_state_access) = _glewSearchExtension("GL_EXT_direct_state_access", extStart, extEnd); + if (glewExperimental || GLEW_EXT_direct_state_access) CONST_CAST(GLEW_EXT_direct_state_access) = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_direct_state_access */ +#ifdef GL_EXT_draw_buffers2 + CONST_CAST(GLEW_EXT_draw_buffers2) = _glewSearchExtension("GL_EXT_draw_buffers2", extStart, extEnd); + if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_instanced + CONST_CAST(GLEW_EXT_draw_instanced) = _glewSearchExtension("GL_EXT_draw_instanced", extStart, extEnd); + if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_instanced */ +#ifdef GL_EXT_draw_range_elements + CONST_CAST(GLEW_EXT_draw_range_elements) = _glewSearchExtension("GL_EXT_draw_range_elements", extStart, extEnd); + if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_fog_coord + CONST_CAST(GLEW_EXT_fog_coord) = _glewSearchExtension("GL_EXT_fog_coord", extStart, extEnd); + if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_fog_coord */ +#ifdef GL_EXT_fragment_lighting + CONST_CAST(GLEW_EXT_fragment_lighting) = _glewSearchExtension("GL_EXT_fragment_lighting", extStart, extEnd); + if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_framebuffer_blit + CONST_CAST(GLEW_EXT_framebuffer_blit) = _glewSearchExtension("GL_EXT_framebuffer_blit", extStart, extEnd); + if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_multisample + CONST_CAST(GLEW_EXT_framebuffer_multisample) = _glewSearchExtension("GL_EXT_framebuffer_multisample", extStart, extEnd); + if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_multisample */ +#ifdef GL_EXT_framebuffer_multisample_blit_scaled + CONST_CAST(GLEW_EXT_framebuffer_multisample_blit_scaled) = _glewSearchExtension("GL_EXT_framebuffer_multisample_blit_scaled", extStart, extEnd); +#endif /* GL_EXT_framebuffer_multisample_blit_scaled */ +#ifdef GL_EXT_framebuffer_object + CONST_CAST(GLEW_EXT_framebuffer_object) = _glewSearchExtension("GL_EXT_framebuffer_object", extStart, extEnd); + if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_object */ +#ifdef GL_EXT_framebuffer_sRGB + CONST_CAST(GLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GL_EXT_framebuffer_sRGB", extStart, extEnd); +#endif /* GL_EXT_framebuffer_sRGB */ +#ifdef GL_EXT_geometry_shader4 + CONST_CAST(GLEW_EXT_geometry_shader4) = _glewSearchExtension("GL_EXT_geometry_shader4", extStart, extEnd); + if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_geometry_shader4 */ +#ifdef GL_EXT_gpu_program_parameters + CONST_CAST(GLEW_EXT_gpu_program_parameters) = _glewSearchExtension("GL_EXT_gpu_program_parameters", extStart, extEnd); + if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_gpu_program_parameters */ +#ifdef GL_EXT_gpu_shader4 + CONST_CAST(GLEW_EXT_gpu_shader4) = _glewSearchExtension("GL_EXT_gpu_shader4", extStart, extEnd); + if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_gpu_shader4 */ +#ifdef GL_EXT_histogram + CONST_CAST(GLEW_EXT_histogram) = _glewSearchExtension("GL_EXT_histogram", extStart, extEnd); + if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_histogram */ +#ifdef GL_EXT_index_array_formats + CONST_CAST(GLEW_EXT_index_array_formats) = _glewSearchExtension("GL_EXT_index_array_formats", extStart, extEnd); +#endif /* GL_EXT_index_array_formats */ +#ifdef GL_EXT_index_func + CONST_CAST(GLEW_EXT_index_func) = _glewSearchExtension("GL_EXT_index_func", extStart, extEnd); + if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_index_func */ +#ifdef GL_EXT_index_material + CONST_CAST(GLEW_EXT_index_material) = _glewSearchExtension("GL_EXT_index_material", extStart, extEnd); + if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_index_material */ +#ifdef GL_EXT_index_texture + CONST_CAST(GLEW_EXT_index_texture) = _glewSearchExtension("GL_EXT_index_texture", extStart, extEnd); +#endif /* GL_EXT_index_texture */ +#ifdef GL_EXT_light_texture + CONST_CAST(GLEW_EXT_light_texture) = _glewSearchExtension("GL_EXT_light_texture", extStart, extEnd); + if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_misc_attribute + CONST_CAST(GLEW_EXT_misc_attribute) = _glewSearchExtension("GL_EXT_misc_attribute", extStart, extEnd); +#endif /* GL_EXT_misc_attribute */ +#ifdef GL_EXT_multi_draw_arrays + CONST_CAST(GLEW_EXT_multi_draw_arrays) = _glewSearchExtension("GL_EXT_multi_draw_arrays", extStart, extEnd); + if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multisample + CONST_CAST(GLEW_EXT_multisample) = _glewSearchExtension("GL_EXT_multisample", extStart, extEnd); + if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_multisample */ +#ifdef GL_EXT_packed_depth_stencil + CONST_CAST(GLEW_EXT_packed_depth_stencil) = _glewSearchExtension("GL_EXT_packed_depth_stencil", extStart, extEnd); +#endif /* GL_EXT_packed_depth_stencil */ +#ifdef GL_EXT_packed_float + CONST_CAST(GLEW_EXT_packed_float) = _glewSearchExtension("GL_EXT_packed_float", extStart, extEnd); +#endif /* GL_EXT_packed_float */ +#ifdef GL_EXT_packed_pixels + CONST_CAST(GLEW_EXT_packed_pixels) = _glewSearchExtension("GL_EXT_packed_pixels", extStart, extEnd); +#endif /* GL_EXT_packed_pixels */ +#ifdef GL_EXT_paletted_texture + CONST_CAST(GLEW_EXT_paletted_texture) = _glewSearchExtension("GL_EXT_paletted_texture", extStart, extEnd); + if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_paletted_texture */ +#ifdef GL_EXT_pixel_buffer_object + CONST_CAST(GLEW_EXT_pixel_buffer_object) = _glewSearchExtension("GL_EXT_pixel_buffer_object", extStart, extEnd); +#endif /* GL_EXT_pixel_buffer_object */ +#ifdef GL_EXT_pixel_transform + CONST_CAST(GLEW_EXT_pixel_transform) = _glewSearchExtension("GL_EXT_pixel_transform", extStart, extEnd); + if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_pixel_transform */ +#ifdef GL_EXT_pixel_transform_color_table + CONST_CAST(GLEW_EXT_pixel_transform_color_table) = _glewSearchExtension("GL_EXT_pixel_transform_color_table", extStart, extEnd); +#endif /* GL_EXT_pixel_transform_color_table */ +#ifdef GL_EXT_point_parameters + CONST_CAST(GLEW_EXT_point_parameters) = _glewSearchExtension("GL_EXT_point_parameters", extStart, extEnd); + if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_point_parameters */ +#ifdef GL_EXT_polygon_offset + CONST_CAST(GLEW_EXT_polygon_offset) = _glewSearchExtension("GL_EXT_polygon_offset", extStart, extEnd); + if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_polygon_offset */ +#ifdef GL_EXT_provoking_vertex + CONST_CAST(GLEW_EXT_provoking_vertex) = _glewSearchExtension("GL_EXT_provoking_vertex", extStart, extEnd); + if (glewExperimental || GLEW_EXT_provoking_vertex) CONST_CAST(GLEW_EXT_provoking_vertex) = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_provoking_vertex */ +#ifdef GL_EXT_rescale_normal + CONST_CAST(GLEW_EXT_rescale_normal) = _glewSearchExtension("GL_EXT_rescale_normal", extStart, extEnd); +#endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_scene_marker + CONST_CAST(GLEW_EXT_scene_marker) = _glewSearchExtension("GL_EXT_scene_marker", extStart, extEnd); + if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_scene_marker */ +#ifdef GL_EXT_secondary_color + CONST_CAST(GLEW_EXT_secondary_color) = _glewSearchExtension("GL_EXT_secondary_color", extStart, extEnd); + if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_separate_shader_objects + CONST_CAST(GLEW_EXT_separate_shader_objects) = _glewSearchExtension("GL_EXT_separate_shader_objects", extStart, extEnd); + if (glewExperimental || GLEW_EXT_separate_shader_objects) CONST_CAST(GLEW_EXT_separate_shader_objects) = !_glewInit_GL_EXT_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_separate_shader_objects */ +#ifdef GL_EXT_separate_specular_color + CONST_CAST(GLEW_EXT_separate_specular_color) = _glewSearchExtension("GL_EXT_separate_specular_color", extStart, extEnd); +#endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shader_image_load_store + CONST_CAST(GLEW_EXT_shader_image_load_store) = _glewSearchExtension("GL_EXT_shader_image_load_store", extStart, extEnd); + if (glewExperimental || GLEW_EXT_shader_image_load_store) CONST_CAST(GLEW_EXT_shader_image_load_store) = !_glewInit_GL_EXT_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_shader_image_load_store */ +#ifdef GL_EXT_shadow_funcs + CONST_CAST(GLEW_EXT_shadow_funcs) = _glewSearchExtension("GL_EXT_shadow_funcs", extStart, extEnd); +#endif /* GL_EXT_shadow_funcs */ +#ifdef GL_EXT_shared_texture_palette + CONST_CAST(GLEW_EXT_shared_texture_palette) = _glewSearchExtension("GL_EXT_shared_texture_palette", extStart, extEnd); +#endif /* GL_EXT_shared_texture_palette */ +#ifdef GL_EXT_stencil_clear_tag + CONST_CAST(GLEW_EXT_stencil_clear_tag) = _glewSearchExtension("GL_EXT_stencil_clear_tag", extStart, extEnd); +#endif /* GL_EXT_stencil_clear_tag */ +#ifdef GL_EXT_stencil_two_side + CONST_CAST(GLEW_EXT_stencil_two_side) = _glewSearchExtension("GL_EXT_stencil_two_side", extStart, extEnd); + if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_stencil_two_side */ +#ifdef GL_EXT_stencil_wrap + CONST_CAST(GLEW_EXT_stencil_wrap) = _glewSearchExtension("GL_EXT_stencil_wrap", extStart, extEnd); +#endif /* GL_EXT_stencil_wrap */ +#ifdef GL_EXT_subtexture + CONST_CAST(GLEW_EXT_subtexture) = _glewSearchExtension("GL_EXT_subtexture", extStart, extEnd); + if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_texture + CONST_CAST(GLEW_EXT_texture) = _glewSearchExtension("GL_EXT_texture", extStart, extEnd); +#endif /* GL_EXT_texture */ +#ifdef GL_EXT_texture3D + CONST_CAST(GLEW_EXT_texture3D) = _glewSearchExtension("GL_EXT_texture3D", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture3D */ +#ifdef GL_EXT_texture_array + CONST_CAST(GLEW_EXT_texture_array) = _glewSearchExtension("GL_EXT_texture_array", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture_array) CONST_CAST(GLEW_EXT_texture_array) = !_glewInit_GL_EXT_texture_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_buffer_object + CONST_CAST(GLEW_EXT_texture_buffer_object) = _glewSearchExtension("GL_EXT_texture_buffer_object", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_buffer_object */ +#ifdef GL_EXT_texture_compression_dxt1 + CONST_CAST(GLEW_EXT_texture_compression_dxt1) = _glewSearchExtension("GL_EXT_texture_compression_dxt1", extStart, extEnd); +#endif /* GL_EXT_texture_compression_dxt1 */ +#ifdef GL_EXT_texture_compression_latc + CONST_CAST(GLEW_EXT_texture_compression_latc) = _glewSearchExtension("GL_EXT_texture_compression_latc", extStart, extEnd); +#endif /* GL_EXT_texture_compression_latc */ +#ifdef GL_EXT_texture_compression_rgtc + CONST_CAST(GLEW_EXT_texture_compression_rgtc) = _glewSearchExtension("GL_EXT_texture_compression_rgtc", extStart, extEnd); +#endif /* GL_EXT_texture_compression_rgtc */ +#ifdef GL_EXT_texture_compression_s3tc + CONST_CAST(GLEW_EXT_texture_compression_s3tc) = _glewSearchExtension("GL_EXT_texture_compression_s3tc", extStart, extEnd); +#endif /* GL_EXT_texture_compression_s3tc */ +#ifdef GL_EXT_texture_cube_map + CONST_CAST(GLEW_EXT_texture_cube_map) = _glewSearchExtension("GL_EXT_texture_cube_map", extStart, extEnd); +#endif /* GL_EXT_texture_cube_map */ +#ifdef GL_EXT_texture_edge_clamp + CONST_CAST(GLEW_EXT_texture_edge_clamp) = _glewSearchExtension("GL_EXT_texture_edge_clamp", extStart, extEnd); +#endif /* GL_EXT_texture_edge_clamp */ +#ifdef GL_EXT_texture_env + CONST_CAST(GLEW_EXT_texture_env) = _glewSearchExtension("GL_EXT_texture_env", extStart, extEnd); +#endif /* GL_EXT_texture_env */ +#ifdef GL_EXT_texture_env_add + CONST_CAST(GLEW_EXT_texture_env_add) = _glewSearchExtension("GL_EXT_texture_env_add", extStart, extEnd); +#endif /* GL_EXT_texture_env_add */ +#ifdef GL_EXT_texture_env_combine + CONST_CAST(GLEW_EXT_texture_env_combine) = _glewSearchExtension("GL_EXT_texture_env_combine", extStart, extEnd); +#endif /* GL_EXT_texture_env_combine */ +#ifdef GL_EXT_texture_env_dot3 + CONST_CAST(GLEW_EXT_texture_env_dot3) = _glewSearchExtension("GL_EXT_texture_env_dot3", extStart, extEnd); +#endif /* GL_EXT_texture_env_dot3 */ +#ifdef GL_EXT_texture_filter_anisotropic + CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = _glewSearchExtension("GL_EXT_texture_filter_anisotropic", extStart, extEnd); +#endif /* GL_EXT_texture_filter_anisotropic */ +#ifdef GL_EXT_texture_integer + CONST_CAST(GLEW_EXT_texture_integer) = _glewSearchExtension("GL_EXT_texture_integer", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_integer */ +#ifdef GL_EXT_texture_lod_bias + CONST_CAST(GLEW_EXT_texture_lod_bias) = _glewSearchExtension("GL_EXT_texture_lod_bias", extStart, extEnd); +#endif /* GL_EXT_texture_lod_bias */ +#ifdef GL_EXT_texture_mirror_clamp + CONST_CAST(GLEW_EXT_texture_mirror_clamp) = _glewSearchExtension("GL_EXT_texture_mirror_clamp", extStart, extEnd); +#endif /* GL_EXT_texture_mirror_clamp */ +#ifdef GL_EXT_texture_object + CONST_CAST(GLEW_EXT_texture_object) = _glewSearchExtension("GL_EXT_texture_object", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_object */ +#ifdef GL_EXT_texture_perturb_normal + CONST_CAST(GLEW_EXT_texture_perturb_normal) = _glewSearchExtension("GL_EXT_texture_perturb_normal", extStart, extEnd); + if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_perturb_normal */ +#ifdef GL_EXT_texture_rectangle + CONST_CAST(GLEW_EXT_texture_rectangle) = _glewSearchExtension("GL_EXT_texture_rectangle", extStart, extEnd); +#endif /* GL_EXT_texture_rectangle */ +#ifdef GL_EXT_texture_sRGB + CONST_CAST(GLEW_EXT_texture_sRGB) = _glewSearchExtension("GL_EXT_texture_sRGB", extStart, extEnd); +#endif /* GL_EXT_texture_sRGB */ +#ifdef GL_EXT_texture_sRGB_decode + CONST_CAST(GLEW_EXT_texture_sRGB_decode) = _glewSearchExtension("GL_EXT_texture_sRGB_decode", extStart, extEnd); +#endif /* GL_EXT_texture_sRGB_decode */ +#ifdef GL_EXT_texture_shared_exponent + CONST_CAST(GLEW_EXT_texture_shared_exponent) = _glewSearchExtension("GL_EXT_texture_shared_exponent", extStart, extEnd); +#endif /* GL_EXT_texture_shared_exponent */ +#ifdef GL_EXT_texture_snorm + CONST_CAST(GLEW_EXT_texture_snorm) = _glewSearchExtension("GL_EXT_texture_snorm", extStart, extEnd); +#endif /* GL_EXT_texture_snorm */ +#ifdef GL_EXT_texture_swizzle + CONST_CAST(GLEW_EXT_texture_swizzle) = _glewSearchExtension("GL_EXT_texture_swizzle", extStart, extEnd); +#endif /* GL_EXT_texture_swizzle */ +#ifdef GL_EXT_timer_query + CONST_CAST(GLEW_EXT_timer_query) = _glewSearchExtension("GL_EXT_timer_query", extStart, extEnd); + if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_timer_query */ +#ifdef GL_EXT_transform_feedback + CONST_CAST(GLEW_EXT_transform_feedback) = _glewSearchExtension("GL_EXT_transform_feedback", extStart, extEnd); + if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_transform_feedback */ +#ifdef GL_EXT_vertex_array + CONST_CAST(GLEW_EXT_vertex_array) = _glewSearchExtension("GL_EXT_vertex_array", extStart, extEnd); + if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_array */ +#ifdef GL_EXT_vertex_array_bgra + CONST_CAST(GLEW_EXT_vertex_array_bgra) = _glewSearchExtension("GL_EXT_vertex_array_bgra", extStart, extEnd); +#endif /* GL_EXT_vertex_array_bgra */ +#ifdef GL_EXT_vertex_attrib_64bit + CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = _glewSearchExtension("GL_EXT_vertex_attrib_64bit", extStart, extEnd); + if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = !_glewInit_GL_EXT_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_attrib_64bit */ +#ifdef GL_EXT_vertex_shader + CONST_CAST(GLEW_EXT_vertex_shader) = _glewSearchExtension("GL_EXT_vertex_shader", extStart, extEnd); + if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_shader */ +#ifdef GL_EXT_vertex_weighting + CONST_CAST(GLEW_EXT_vertex_weighting) = _glewSearchExtension("GL_EXT_vertex_weighting", extStart, extEnd); + if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_weighting */ +#ifdef GL_EXT_x11_sync_object + CONST_CAST(GLEW_EXT_x11_sync_object) = _glewSearchExtension("GL_EXT_x11_sync_object", extStart, extEnd); + if (glewExperimental || GLEW_EXT_x11_sync_object) CONST_CAST(GLEW_EXT_x11_sync_object) = !_glewInit_GL_EXT_x11_sync_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_x11_sync_object */ +#ifdef GL_GREMEDY_frame_terminator + CONST_CAST(GLEW_GREMEDY_frame_terminator) = _glewSearchExtension("GL_GREMEDY_frame_terminator", extStart, extEnd); + if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_GREMEDY_frame_terminator */ +#ifdef GL_GREMEDY_string_marker + CONST_CAST(GLEW_GREMEDY_string_marker) = _glewSearchExtension("GL_GREMEDY_string_marker", extStart, extEnd); + if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_GREMEDY_string_marker */ +#ifdef GL_HP_convolution_border_modes + CONST_CAST(GLEW_HP_convolution_border_modes) = _glewSearchExtension("GL_HP_convolution_border_modes", extStart, extEnd); +#endif /* GL_HP_convolution_border_modes */ +#ifdef GL_HP_image_transform + CONST_CAST(GLEW_HP_image_transform) = _glewSearchExtension("GL_HP_image_transform", extStart, extEnd); + if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_HP_image_transform */ +#ifdef GL_HP_occlusion_test + CONST_CAST(GLEW_HP_occlusion_test) = _glewSearchExtension("GL_HP_occlusion_test", extStart, extEnd); +#endif /* GL_HP_occlusion_test */ +#ifdef GL_HP_texture_lighting + CONST_CAST(GLEW_HP_texture_lighting) = _glewSearchExtension("GL_HP_texture_lighting", extStart, extEnd); +#endif /* GL_HP_texture_lighting */ +#ifdef GL_IBM_cull_vertex + CONST_CAST(GLEW_IBM_cull_vertex) = _glewSearchExtension("GL_IBM_cull_vertex", extStart, extEnd); +#endif /* GL_IBM_cull_vertex */ +#ifdef GL_IBM_multimode_draw_arrays + CONST_CAST(GLEW_IBM_multimode_draw_arrays) = _glewSearchExtension("GL_IBM_multimode_draw_arrays", extStart, extEnd); + if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_IBM_multimode_draw_arrays */ +#ifdef GL_IBM_rasterpos_clip + CONST_CAST(GLEW_IBM_rasterpos_clip) = _glewSearchExtension("GL_IBM_rasterpos_clip", extStart, extEnd); +#endif /* GL_IBM_rasterpos_clip */ +#ifdef GL_IBM_static_data + CONST_CAST(GLEW_IBM_static_data) = _glewSearchExtension("GL_IBM_static_data", extStart, extEnd); +#endif /* GL_IBM_static_data */ +#ifdef GL_IBM_texture_mirrored_repeat + CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = _glewSearchExtension("GL_IBM_texture_mirrored_repeat", extStart, extEnd); +#endif /* GL_IBM_texture_mirrored_repeat */ +#ifdef GL_IBM_vertex_array_lists + CONST_CAST(GLEW_IBM_vertex_array_lists) = _glewSearchExtension("GL_IBM_vertex_array_lists", extStart, extEnd); + if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_INGR_color_clamp + CONST_CAST(GLEW_INGR_color_clamp) = _glewSearchExtension("GL_INGR_color_clamp", extStart, extEnd); +#endif /* GL_INGR_color_clamp */ +#ifdef GL_INGR_interlace_read + CONST_CAST(GLEW_INGR_interlace_read) = _glewSearchExtension("GL_INGR_interlace_read", extStart, extEnd); +#endif /* GL_INGR_interlace_read */ +#ifdef GL_INTEL_parallel_arrays + CONST_CAST(GLEW_INTEL_parallel_arrays) = _glewSearchExtension("GL_INTEL_parallel_arrays", extStart, extEnd); + if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_INTEL_parallel_arrays */ +#ifdef GL_INTEL_texture_scissor + CONST_CAST(GLEW_INTEL_texture_scissor) = _glewSearchExtension("GL_INTEL_texture_scissor", extStart, extEnd); + if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_INTEL_texture_scissor */ +#ifdef GL_KTX_buffer_region + CONST_CAST(GLEW_KTX_buffer_region) = _glewSearchExtension("GL_KTX_buffer_region", extStart, extEnd); + if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_KTX_buffer_region */ +#ifdef GL_MESAX_texture_stack + CONST_CAST(GLEW_MESAX_texture_stack) = _glewSearchExtension("GL_MESAX_texture_stack", extStart, extEnd); +#endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_pack_invert + CONST_CAST(GLEW_MESA_pack_invert) = _glewSearchExtension("GL_MESA_pack_invert", extStart, extEnd); +#endif /* GL_MESA_pack_invert */ +#ifdef GL_MESA_resize_buffers + CONST_CAST(GLEW_MESA_resize_buffers) = _glewSearchExtension("GL_MESA_resize_buffers", extStart, extEnd); + if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_MESA_resize_buffers */ +#ifdef GL_MESA_window_pos + CONST_CAST(GLEW_MESA_window_pos) = _glewSearchExtension("GL_MESA_window_pos", extStart, extEnd); + if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_MESA_window_pos */ +#ifdef GL_MESA_ycbcr_texture + CONST_CAST(GLEW_MESA_ycbcr_texture) = _glewSearchExtension("GL_MESA_ycbcr_texture", extStart, extEnd); +#endif /* GL_MESA_ycbcr_texture */ +#ifdef GL_NVX_gpu_memory_info + CONST_CAST(GLEW_NVX_gpu_memory_info) = _glewSearchExtension("GL_NVX_gpu_memory_info", extStart, extEnd); +#endif /* GL_NVX_gpu_memory_info */ +#ifdef GL_NV_blend_square + CONST_CAST(GLEW_NV_blend_square) = _glewSearchExtension("GL_NV_blend_square", extStart, extEnd); +#endif /* GL_NV_blend_square */ +#ifdef GL_NV_conditional_render + CONST_CAST(GLEW_NV_conditional_render) = _glewSearchExtension("GL_NV_conditional_render", extStart, extEnd); + if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_conditional_render */ +#ifdef GL_NV_copy_depth_to_color + CONST_CAST(GLEW_NV_copy_depth_to_color) = _glewSearchExtension("GL_NV_copy_depth_to_color", extStart, extEnd); +#endif /* GL_NV_copy_depth_to_color */ +#ifdef GL_NV_copy_image + CONST_CAST(GLEW_NV_copy_image) = _glewSearchExtension("GL_NV_copy_image", extStart, extEnd); + if (glewExperimental || GLEW_NV_copy_image) CONST_CAST(GLEW_NV_copy_image) = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_copy_image */ +#ifdef GL_NV_depth_buffer_float + CONST_CAST(GLEW_NV_depth_buffer_float) = _glewSearchExtension("GL_NV_depth_buffer_float", extStart, extEnd); + if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_depth_buffer_float */ +#ifdef GL_NV_depth_clamp + CONST_CAST(GLEW_NV_depth_clamp) = _glewSearchExtension("GL_NV_depth_clamp", extStart, extEnd); +#endif /* GL_NV_depth_clamp */ +#ifdef GL_NV_depth_range_unclamped + CONST_CAST(GLEW_NV_depth_range_unclamped) = _glewSearchExtension("GL_NV_depth_range_unclamped", extStart, extEnd); +#endif /* GL_NV_depth_range_unclamped */ +#ifdef GL_NV_evaluators + CONST_CAST(GLEW_NV_evaluators) = _glewSearchExtension("GL_NV_evaluators", extStart, extEnd); + if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_evaluators */ +#ifdef GL_NV_explicit_multisample + CONST_CAST(GLEW_NV_explicit_multisample) = _glewSearchExtension("GL_NV_explicit_multisample", extStart, extEnd); + if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_explicit_multisample */ +#ifdef GL_NV_fence + CONST_CAST(GLEW_NV_fence) = _glewSearchExtension("GL_NV_fence", extStart, extEnd); + if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_fence */ +#ifdef GL_NV_float_buffer + CONST_CAST(GLEW_NV_float_buffer) = _glewSearchExtension("GL_NV_float_buffer", extStart, extEnd); +#endif /* GL_NV_float_buffer */ +#ifdef GL_NV_fog_distance + CONST_CAST(GLEW_NV_fog_distance) = _glewSearchExtension("GL_NV_fog_distance", extStart, extEnd); +#endif /* GL_NV_fog_distance */ +#ifdef GL_NV_fragment_program + CONST_CAST(GLEW_NV_fragment_program) = _glewSearchExtension("GL_NV_fragment_program", extStart, extEnd); + if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_fragment_program */ +#ifdef GL_NV_fragment_program2 + CONST_CAST(GLEW_NV_fragment_program2) = _glewSearchExtension("GL_NV_fragment_program2", extStart, extEnd); +#endif /* GL_NV_fragment_program2 */ +#ifdef GL_NV_fragment_program4 + CONST_CAST(GLEW_NV_fragment_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); +#endif /* GL_NV_fragment_program4 */ +#ifdef GL_NV_fragment_program_option + CONST_CAST(GLEW_NV_fragment_program_option) = _glewSearchExtension("GL_NV_fragment_program_option", extStart, extEnd); +#endif /* GL_NV_fragment_program_option */ +#ifdef GL_NV_framebuffer_multisample_coverage + CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = _glewSearchExtension("GL_NV_framebuffer_multisample_coverage", extStart, extEnd); + if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_framebuffer_multisample_coverage */ +#ifdef GL_NV_geometry_program4 + CONST_CAST(GLEW_NV_geometry_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); + if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_geometry_program4 */ +#ifdef GL_NV_geometry_shader4 + CONST_CAST(GLEW_NV_geometry_shader4) = _glewSearchExtension("GL_NV_geometry_shader4", extStart, extEnd); +#endif /* GL_NV_geometry_shader4 */ +#ifdef GL_NV_gpu_program4 + CONST_CAST(GLEW_NV_gpu_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); + if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_gpu_program4 */ +#ifdef GL_NV_gpu_program5 + CONST_CAST(GLEW_NV_gpu_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd); +#endif /* GL_NV_gpu_program5 */ +#ifdef GL_NV_gpu_program_fp64 + CONST_CAST(GLEW_NV_gpu_program_fp64) = _glewSearchExtension("GL_NV_gpu_program_fp64", extStart, extEnd); +#endif /* GL_NV_gpu_program_fp64 */ +#ifdef GL_NV_gpu_shader5 + CONST_CAST(GLEW_NV_gpu_shader5) = _glewSearchExtension("GL_NV_gpu_shader5", extStart, extEnd); + if (glewExperimental || GLEW_NV_gpu_shader5) CONST_CAST(GLEW_NV_gpu_shader5) = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_gpu_shader5 */ +#ifdef GL_NV_half_float + CONST_CAST(GLEW_NV_half_float) = _glewSearchExtension("GL_NV_half_float", extStart, extEnd); + if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_half_float */ +#ifdef GL_NV_light_max_exponent + CONST_CAST(GLEW_NV_light_max_exponent) = _glewSearchExtension("GL_NV_light_max_exponent", extStart, extEnd); +#endif /* GL_NV_light_max_exponent */ +#ifdef GL_NV_multisample_coverage + CONST_CAST(GLEW_NV_multisample_coverage) = _glewSearchExtension("GL_NV_multisample_coverage", extStart, extEnd); +#endif /* GL_NV_multisample_coverage */ +#ifdef GL_NV_multisample_filter_hint + CONST_CAST(GLEW_NV_multisample_filter_hint) = _glewSearchExtension("GL_NV_multisample_filter_hint", extStart, extEnd); +#endif /* GL_NV_multisample_filter_hint */ +#ifdef GL_NV_occlusion_query + CONST_CAST(GLEW_NV_occlusion_query) = _glewSearchExtension("GL_NV_occlusion_query", extStart, extEnd); + if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_occlusion_query */ +#ifdef GL_NV_packed_depth_stencil + CONST_CAST(GLEW_NV_packed_depth_stencil) = _glewSearchExtension("GL_NV_packed_depth_stencil", extStart, extEnd); +#endif /* GL_NV_packed_depth_stencil */ +#ifdef GL_NV_parameter_buffer_object + CONST_CAST(GLEW_NV_parameter_buffer_object) = _glewSearchExtension("GL_NV_parameter_buffer_object", extStart, extEnd); + if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_parameter_buffer_object */ +#ifdef GL_NV_parameter_buffer_object2 + CONST_CAST(GLEW_NV_parameter_buffer_object2) = _glewSearchExtension("GL_NV_parameter_buffer_object2", extStart, extEnd); +#endif /* GL_NV_parameter_buffer_object2 */ +#ifdef GL_NV_path_rendering + CONST_CAST(GLEW_NV_path_rendering) = _glewSearchExtension("GL_NV_path_rendering", extStart, extEnd); + if (glewExperimental || GLEW_NV_path_rendering) CONST_CAST(GLEW_NV_path_rendering) = !_glewInit_GL_NV_path_rendering(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_path_rendering */ +#ifdef GL_NV_pixel_data_range + CONST_CAST(GLEW_NV_pixel_data_range) = _glewSearchExtension("GL_NV_pixel_data_range", extStart, extEnd); + if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_pixel_data_range */ +#ifdef GL_NV_point_sprite + CONST_CAST(GLEW_NV_point_sprite) = _glewSearchExtension("GL_NV_point_sprite", extStart, extEnd); + if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_point_sprite */ +#ifdef GL_NV_present_video + CONST_CAST(GLEW_NV_present_video) = _glewSearchExtension("GL_NV_present_video", extStart, extEnd); + if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_present_video */ +#ifdef GL_NV_primitive_restart + CONST_CAST(GLEW_NV_primitive_restart) = _glewSearchExtension("GL_NV_primitive_restart", extStart, extEnd); + if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_register_combiners + CONST_CAST(GLEW_NV_register_combiners) = _glewSearchExtension("GL_NV_register_combiners", extStart, extEnd); + if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_register_combiners */ +#ifdef GL_NV_register_combiners2 + CONST_CAST(GLEW_NV_register_combiners2) = _glewSearchExtension("GL_NV_register_combiners2", extStart, extEnd); + if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_register_combiners2 */ +#ifdef GL_NV_shader_buffer_load + CONST_CAST(GLEW_NV_shader_buffer_load) = _glewSearchExtension("GL_NV_shader_buffer_load", extStart, extEnd); + if (glewExperimental || GLEW_NV_shader_buffer_load) CONST_CAST(GLEW_NV_shader_buffer_load) = !_glewInit_GL_NV_shader_buffer_load(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_tessellation_program5 + CONST_CAST(GLEW_NV_tessellation_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd); +#endif /* GL_NV_tessellation_program5 */ +#ifdef GL_NV_texgen_emboss + CONST_CAST(GLEW_NV_texgen_emboss) = _glewSearchExtension("GL_NV_texgen_emboss", extStart, extEnd); +#endif /* GL_NV_texgen_emboss */ +#ifdef GL_NV_texgen_reflection + CONST_CAST(GLEW_NV_texgen_reflection) = _glewSearchExtension("GL_NV_texgen_reflection", extStart, extEnd); +#endif /* GL_NV_texgen_reflection */ +#ifdef GL_NV_texture_barrier + CONST_CAST(GLEW_NV_texture_barrier) = _glewSearchExtension("GL_NV_texture_barrier", extStart, extEnd); + if (glewExperimental || GLEW_NV_texture_barrier) CONST_CAST(GLEW_NV_texture_barrier) = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_texture_barrier */ +#ifdef GL_NV_texture_compression_vtc + CONST_CAST(GLEW_NV_texture_compression_vtc) = _glewSearchExtension("GL_NV_texture_compression_vtc", extStart, extEnd); +#endif /* GL_NV_texture_compression_vtc */ +#ifdef GL_NV_texture_env_combine4 + CONST_CAST(GLEW_NV_texture_env_combine4) = _glewSearchExtension("GL_NV_texture_env_combine4", extStart, extEnd); +#endif /* GL_NV_texture_env_combine4 */ +#ifdef GL_NV_texture_expand_normal + CONST_CAST(GLEW_NV_texture_expand_normal) = _glewSearchExtension("GL_NV_texture_expand_normal", extStart, extEnd); +#endif /* GL_NV_texture_expand_normal */ +#ifdef GL_NV_texture_multisample + CONST_CAST(GLEW_NV_texture_multisample) = _glewSearchExtension("GL_NV_texture_multisample", extStart, extEnd); + if (glewExperimental || GLEW_NV_texture_multisample) CONST_CAST(GLEW_NV_texture_multisample) = !_glewInit_GL_NV_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_texture_multisample */ +#ifdef GL_NV_texture_rectangle + CONST_CAST(GLEW_NV_texture_rectangle) = _glewSearchExtension("GL_NV_texture_rectangle", extStart, extEnd); +#endif /* GL_NV_texture_rectangle */ +#ifdef GL_NV_texture_shader + CONST_CAST(GLEW_NV_texture_shader) = _glewSearchExtension("GL_NV_texture_shader", extStart, extEnd); +#endif /* GL_NV_texture_shader */ +#ifdef GL_NV_texture_shader2 + CONST_CAST(GLEW_NV_texture_shader2) = _glewSearchExtension("GL_NV_texture_shader2", extStart, extEnd); +#endif /* GL_NV_texture_shader2 */ +#ifdef GL_NV_texture_shader3 + CONST_CAST(GLEW_NV_texture_shader3) = _glewSearchExtension("GL_NV_texture_shader3", extStart, extEnd); +#endif /* GL_NV_texture_shader3 */ +#ifdef GL_NV_transform_feedback + CONST_CAST(GLEW_NV_transform_feedback) = _glewSearchExtension("GL_NV_transform_feedback", extStart, extEnd); + if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_transform_feedback */ +#ifdef GL_NV_transform_feedback2 + CONST_CAST(GLEW_NV_transform_feedback2) = _glewSearchExtension("GL_NV_transform_feedback2", extStart, extEnd); + if (glewExperimental || GLEW_NV_transform_feedback2) CONST_CAST(GLEW_NV_transform_feedback2) = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_transform_feedback2 */ +#ifdef GL_NV_vdpau_interop + CONST_CAST(GLEW_NV_vdpau_interop) = _glewSearchExtension("GL_NV_vdpau_interop", extStart, extEnd); + if (glewExperimental || GLEW_NV_vdpau_interop) CONST_CAST(GLEW_NV_vdpau_interop) = !_glewInit_GL_NV_vdpau_interop(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vdpau_interop */ +#ifdef GL_NV_vertex_array_range + CONST_CAST(GLEW_NV_vertex_array_range) = _glewSearchExtension("GL_NV_vertex_array_range", extStart, extEnd); + if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_array_range */ +#ifdef GL_NV_vertex_array_range2 + CONST_CAST(GLEW_NV_vertex_array_range2) = _glewSearchExtension("GL_NV_vertex_array_range2", extStart, extEnd); +#endif /* GL_NV_vertex_array_range2 */ +#ifdef GL_NV_vertex_attrib_integer_64bit + CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = _glewSearchExtension("GL_NV_vertex_attrib_integer_64bit", extStart, extEnd); + if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = !_glewInit_GL_NV_vertex_attrib_integer_64bit(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_attrib_integer_64bit */ +#ifdef GL_NV_vertex_buffer_unified_memory + CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = _glewSearchExtension("GL_NV_vertex_buffer_unified_memory", extStart, extEnd); + if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = !_glewInit_GL_NV_vertex_buffer_unified_memory(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_buffer_unified_memory */ +#ifdef GL_NV_vertex_program + CONST_CAST(GLEW_NV_vertex_program) = _glewSearchExtension("GL_NV_vertex_program", extStart, extEnd); + if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_program */ +#ifdef GL_NV_vertex_program1_1 + CONST_CAST(GLEW_NV_vertex_program1_1) = _glewSearchExtension("GL_NV_vertex_program1_1", extStart, extEnd); +#endif /* GL_NV_vertex_program1_1 */ +#ifdef GL_NV_vertex_program2 + CONST_CAST(GLEW_NV_vertex_program2) = _glewSearchExtension("GL_NV_vertex_program2", extStart, extEnd); +#endif /* GL_NV_vertex_program2 */ +#ifdef GL_NV_vertex_program2_option + CONST_CAST(GLEW_NV_vertex_program2_option) = _glewSearchExtension("GL_NV_vertex_program2_option", extStart, extEnd); +#endif /* GL_NV_vertex_program2_option */ +#ifdef GL_NV_vertex_program3 + CONST_CAST(GLEW_NV_vertex_program3) = _glewSearchExtension("GL_NV_vertex_program3", extStart, extEnd); +#endif /* GL_NV_vertex_program3 */ +#ifdef GL_NV_vertex_program4 + CONST_CAST(GLEW_NV_vertex_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); +#endif /* GL_NV_vertex_program4 */ +#ifdef GL_NV_video_capture + CONST_CAST(GLEW_NV_video_capture) = _glewSearchExtension("GL_NV_video_capture", extStart, extEnd); + if (glewExperimental || GLEW_NV_video_capture) CONST_CAST(GLEW_NV_video_capture) = !_glewInit_GL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_video_capture */ +#ifdef GL_OES_byte_coordinates + CONST_CAST(GLEW_OES_byte_coordinates) = _glewSearchExtension("GL_OES_byte_coordinates", extStart, extEnd); +#endif /* GL_OES_byte_coordinates */ +#ifdef GL_OES_compressed_paletted_texture + CONST_CAST(GLEW_OES_compressed_paletted_texture) = _glewSearchExtension("GL_OES_compressed_paletted_texture", extStart, extEnd); +#endif /* GL_OES_compressed_paletted_texture */ +#ifdef GL_OES_read_format + CONST_CAST(GLEW_OES_read_format) = _glewSearchExtension("GL_OES_read_format", extStart, extEnd); +#endif /* GL_OES_read_format */ +#ifdef GL_OES_single_precision + CONST_CAST(GLEW_OES_single_precision) = _glewSearchExtension("GL_OES_single_precision", extStart, extEnd); + if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_OES_single_precision */ +#ifdef GL_OML_interlace + CONST_CAST(GLEW_OML_interlace) = _glewSearchExtension("GL_OML_interlace", extStart, extEnd); +#endif /* GL_OML_interlace */ +#ifdef GL_OML_resample + CONST_CAST(GLEW_OML_resample) = _glewSearchExtension("GL_OML_resample", extStart, extEnd); +#endif /* GL_OML_resample */ +#ifdef GL_OML_subsample + CONST_CAST(GLEW_OML_subsample) = _glewSearchExtension("GL_OML_subsample", extStart, extEnd); +#endif /* GL_OML_subsample */ +#ifdef GL_PGI_misc_hints + CONST_CAST(GLEW_PGI_misc_hints) = _glewSearchExtension("GL_PGI_misc_hints", extStart, extEnd); +#endif /* GL_PGI_misc_hints */ +#ifdef GL_PGI_vertex_hints + CONST_CAST(GLEW_PGI_vertex_hints) = _glewSearchExtension("GL_PGI_vertex_hints", extStart, extEnd); +#endif /* GL_PGI_vertex_hints */ +#ifdef GL_REND_screen_coordinates + CONST_CAST(GLEW_REND_screen_coordinates) = _glewSearchExtension("GL_REND_screen_coordinates", extStart, extEnd); +#endif /* GL_REND_screen_coordinates */ +#ifdef GL_S3_s3tc + CONST_CAST(GLEW_S3_s3tc) = _glewSearchExtension("GL_S3_s3tc", extStart, extEnd); +#endif /* GL_S3_s3tc */ +#ifdef GL_SGIS_color_range + CONST_CAST(GLEW_SGIS_color_range) = _glewSearchExtension("GL_SGIS_color_range", extStart, extEnd); +#endif /* GL_SGIS_color_range */ +#ifdef GL_SGIS_detail_texture + CONST_CAST(GLEW_SGIS_detail_texture) = _glewSearchExtension("GL_SGIS_detail_texture", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_detail_texture */ +#ifdef GL_SGIS_fog_function + CONST_CAST(GLEW_SGIS_fog_function) = _glewSearchExtension("GL_SGIS_fog_function", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_fog_function */ +#ifdef GL_SGIS_generate_mipmap + CONST_CAST(GLEW_SGIS_generate_mipmap) = _glewSearchExtension("GL_SGIS_generate_mipmap", extStart, extEnd); +#endif /* GL_SGIS_generate_mipmap */ +#ifdef GL_SGIS_multisample + CONST_CAST(GLEW_SGIS_multisample) = _glewSearchExtension("GL_SGIS_multisample", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_pixel_texture + CONST_CAST(GLEW_SGIS_pixel_texture) = _glewSearchExtension("GL_SGIS_pixel_texture", extStart, extEnd); +#endif /* GL_SGIS_pixel_texture */ +#ifdef GL_SGIS_point_line_texgen + CONST_CAST(GLEW_SGIS_point_line_texgen) = _glewSearchExtension("GL_SGIS_point_line_texgen", extStart, extEnd); +#endif /* GL_SGIS_point_line_texgen */ +#ifdef GL_SGIS_sharpen_texture + CONST_CAST(GLEW_SGIS_sharpen_texture) = _glewSearchExtension("GL_SGIS_sharpen_texture", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_sharpen_texture */ +#ifdef GL_SGIS_texture4D + CONST_CAST(GLEW_SGIS_texture4D) = _glewSearchExtension("GL_SGIS_texture4D", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_texture4D */ +#ifdef GL_SGIS_texture_border_clamp + CONST_CAST(GLEW_SGIS_texture_border_clamp) = _glewSearchExtension("GL_SGIS_texture_border_clamp", extStart, extEnd); +#endif /* GL_SGIS_texture_border_clamp */ +#ifdef GL_SGIS_texture_edge_clamp + CONST_CAST(GLEW_SGIS_texture_edge_clamp) = _glewSearchExtension("GL_SGIS_texture_edge_clamp", extStart, extEnd); +#endif /* GL_SGIS_texture_edge_clamp */ +#ifdef GL_SGIS_texture_filter4 + CONST_CAST(GLEW_SGIS_texture_filter4) = _glewSearchExtension("GL_SGIS_texture_filter4", extStart, extEnd); + if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_texture_filter4 */ +#ifdef GL_SGIS_texture_lod + CONST_CAST(GLEW_SGIS_texture_lod) = _glewSearchExtension("GL_SGIS_texture_lod", extStart, extEnd); +#endif /* GL_SGIS_texture_lod */ +#ifdef GL_SGIS_texture_select + CONST_CAST(GLEW_SGIS_texture_select) = _glewSearchExtension("GL_SGIS_texture_select", extStart, extEnd); +#endif /* GL_SGIS_texture_select */ +#ifdef GL_SGIX_async + CONST_CAST(GLEW_SGIX_async) = _glewSearchExtension("GL_SGIX_async", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_async */ +#ifdef GL_SGIX_async_histogram + CONST_CAST(GLEW_SGIX_async_histogram) = _glewSearchExtension("GL_SGIX_async_histogram", extStart, extEnd); +#endif /* GL_SGIX_async_histogram */ +#ifdef GL_SGIX_async_pixel + CONST_CAST(GLEW_SGIX_async_pixel) = _glewSearchExtension("GL_SGIX_async_pixel", extStart, extEnd); +#endif /* GL_SGIX_async_pixel */ +#ifdef GL_SGIX_blend_alpha_minmax + CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = _glewSearchExtension("GL_SGIX_blend_alpha_minmax", extStart, extEnd); +#endif /* GL_SGIX_blend_alpha_minmax */ +#ifdef GL_SGIX_clipmap + CONST_CAST(GLEW_SGIX_clipmap) = _glewSearchExtension("GL_SGIX_clipmap", extStart, extEnd); +#endif /* GL_SGIX_clipmap */ +#ifdef GL_SGIX_convolution_accuracy + CONST_CAST(GLEW_SGIX_convolution_accuracy) = _glewSearchExtension("GL_SGIX_convolution_accuracy", extStart, extEnd); +#endif /* GL_SGIX_convolution_accuracy */ +#ifdef GL_SGIX_depth_texture + CONST_CAST(GLEW_SGIX_depth_texture) = _glewSearchExtension("GL_SGIX_depth_texture", extStart, extEnd); +#endif /* GL_SGIX_depth_texture */ +#ifdef GL_SGIX_flush_raster + CONST_CAST(GLEW_SGIX_flush_raster) = _glewSearchExtension("GL_SGIX_flush_raster", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_offset + CONST_CAST(GLEW_SGIX_fog_offset) = _glewSearchExtension("GL_SGIX_fog_offset", extStart, extEnd); +#endif /* GL_SGIX_fog_offset */ +#ifdef GL_SGIX_fog_texture + CONST_CAST(GLEW_SGIX_fog_texture) = _glewSearchExtension("GL_SGIX_fog_texture", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_fog_texture */ +#ifdef GL_SGIX_fragment_specular_lighting + CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = _glewSearchExtension("GL_SGIX_fragment_specular_lighting", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_fragment_specular_lighting */ +#ifdef GL_SGIX_framezoom + CONST_CAST(GLEW_SGIX_framezoom) = _glewSearchExtension("GL_SGIX_framezoom", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_interlace + CONST_CAST(GLEW_SGIX_interlace) = _glewSearchExtension("GL_SGIX_interlace", extStart, extEnd); +#endif /* GL_SGIX_interlace */ +#ifdef GL_SGIX_ir_instrument1 + CONST_CAST(GLEW_SGIX_ir_instrument1) = _glewSearchExtension("GL_SGIX_ir_instrument1", extStart, extEnd); +#endif /* GL_SGIX_ir_instrument1 */ +#ifdef GL_SGIX_list_priority + CONST_CAST(GLEW_SGIX_list_priority) = _glewSearchExtension("GL_SGIX_list_priority", extStart, extEnd); +#endif /* GL_SGIX_list_priority */ +#ifdef GL_SGIX_pixel_texture + CONST_CAST(GLEW_SGIX_pixel_texture) = _glewSearchExtension("GL_SGIX_pixel_texture", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_pixel_texture */ +#ifdef GL_SGIX_pixel_texture_bits + CONST_CAST(GLEW_SGIX_pixel_texture_bits) = _glewSearchExtension("GL_SGIX_pixel_texture_bits", extStart, extEnd); +#endif /* GL_SGIX_pixel_texture_bits */ +#ifdef GL_SGIX_reference_plane + CONST_CAST(GLEW_SGIX_reference_plane) = _glewSearchExtension("GL_SGIX_reference_plane", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_reference_plane */ +#ifdef GL_SGIX_resample + CONST_CAST(GLEW_SGIX_resample) = _glewSearchExtension("GL_SGIX_resample", extStart, extEnd); +#endif /* GL_SGIX_resample */ +#ifdef GL_SGIX_shadow + CONST_CAST(GLEW_SGIX_shadow) = _glewSearchExtension("GL_SGIX_shadow", extStart, extEnd); +#endif /* GL_SGIX_shadow */ +#ifdef GL_SGIX_shadow_ambient + CONST_CAST(GLEW_SGIX_shadow_ambient) = _glewSearchExtension("GL_SGIX_shadow_ambient", extStart, extEnd); +#endif /* GL_SGIX_shadow_ambient */ +#ifdef GL_SGIX_sprite + CONST_CAST(GLEW_SGIX_sprite) = _glewSearchExtension("GL_SGIX_sprite", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_sprite */ +#ifdef GL_SGIX_tag_sample_buffer + CONST_CAST(GLEW_SGIX_tag_sample_buffer) = _glewSearchExtension("GL_SGIX_tag_sample_buffer", extStart, extEnd); + if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_tag_sample_buffer */ +#ifdef GL_SGIX_texture_add_env + CONST_CAST(GLEW_SGIX_texture_add_env) = _glewSearchExtension("GL_SGIX_texture_add_env", extStart, extEnd); +#endif /* GL_SGIX_texture_add_env */ +#ifdef GL_SGIX_texture_coordinate_clamp + CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = _glewSearchExtension("GL_SGIX_texture_coordinate_clamp", extStart, extEnd); +#endif /* GL_SGIX_texture_coordinate_clamp */ +#ifdef GL_SGIX_texture_lod_bias + CONST_CAST(GLEW_SGIX_texture_lod_bias) = _glewSearchExtension("GL_SGIX_texture_lod_bias", extStart, extEnd); +#endif /* GL_SGIX_texture_lod_bias */ +#ifdef GL_SGIX_texture_multi_buffer + CONST_CAST(GLEW_SGIX_texture_multi_buffer) = _glewSearchExtension("GL_SGIX_texture_multi_buffer", extStart, extEnd); +#endif /* GL_SGIX_texture_multi_buffer */ +#ifdef GL_SGIX_texture_range + CONST_CAST(GLEW_SGIX_texture_range) = _glewSearchExtension("GL_SGIX_texture_range", extStart, extEnd); +#endif /* GL_SGIX_texture_range */ +#ifdef GL_SGIX_texture_scale_bias + CONST_CAST(GLEW_SGIX_texture_scale_bias) = _glewSearchExtension("GL_SGIX_texture_scale_bias", extStart, extEnd); +#endif /* GL_SGIX_texture_scale_bias */ +#ifdef GL_SGIX_vertex_preclip + CONST_CAST(GLEW_SGIX_vertex_preclip) = _glewSearchExtension("GL_SGIX_vertex_preclip", extStart, extEnd); +#endif /* GL_SGIX_vertex_preclip */ +#ifdef GL_SGIX_vertex_preclip_hint + CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = _glewSearchExtension("GL_SGIX_vertex_preclip_hint", extStart, extEnd); +#endif /* GL_SGIX_vertex_preclip_hint */ +#ifdef GL_SGIX_ycrcb + CONST_CAST(GLEW_SGIX_ycrcb) = _glewSearchExtension("GL_SGIX_ycrcb", extStart, extEnd); +#endif /* GL_SGIX_ycrcb */ +#ifdef GL_SGI_color_matrix + CONST_CAST(GLEW_SGI_color_matrix) = _glewSearchExtension("GL_SGI_color_matrix", extStart, extEnd); +#endif /* GL_SGI_color_matrix */ +#ifdef GL_SGI_color_table + CONST_CAST(GLEW_SGI_color_table) = _glewSearchExtension("GL_SGI_color_table", extStart, extEnd); + if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGI_color_table */ +#ifdef GL_SGI_texture_color_table + CONST_CAST(GLEW_SGI_texture_color_table) = _glewSearchExtension("GL_SGI_texture_color_table", extStart, extEnd); +#endif /* GL_SGI_texture_color_table */ +#ifdef GL_SUNX_constant_data + CONST_CAST(GLEW_SUNX_constant_data) = _glewSearchExtension("GL_SUNX_constant_data", extStart, extEnd); + if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUNX_constant_data */ +#ifdef GL_SUN_convolution_border_modes + CONST_CAST(GLEW_SUN_convolution_border_modes) = _glewSearchExtension("GL_SUN_convolution_border_modes", extStart, extEnd); +#endif /* GL_SUN_convolution_border_modes */ +#ifdef GL_SUN_global_alpha + CONST_CAST(GLEW_SUN_global_alpha) = _glewSearchExtension("GL_SUN_global_alpha", extStart, extEnd); + if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_global_alpha */ +#ifdef GL_SUN_mesh_array + CONST_CAST(GLEW_SUN_mesh_array) = _glewSearchExtension("GL_SUN_mesh_array", extStart, extEnd); +#endif /* GL_SUN_mesh_array */ +#ifdef GL_SUN_read_video_pixels + CONST_CAST(GLEW_SUN_read_video_pixels) = _glewSearchExtension("GL_SUN_read_video_pixels", extStart, extEnd); + if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_read_video_pixels */ +#ifdef GL_SUN_slice_accum + CONST_CAST(GLEW_SUN_slice_accum) = _glewSearchExtension("GL_SUN_slice_accum", extStart, extEnd); +#endif /* GL_SUN_slice_accum */ +#ifdef GL_SUN_triangle_list + CONST_CAST(GLEW_SUN_triangle_list) = _glewSearchExtension("GL_SUN_triangle_list", extStart, extEnd); + if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_triangle_list */ +#ifdef GL_SUN_vertex + CONST_CAST(GLEW_SUN_vertex) = _glewSearchExtension("GL_SUN_vertex", extStart, extEnd); + if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_vertex */ +#ifdef GL_WIN_phong_shading + CONST_CAST(GLEW_WIN_phong_shading) = _glewSearchExtension("GL_WIN_phong_shading", extStart, extEnd); +#endif /* GL_WIN_phong_shading */ +#ifdef GL_WIN_specular_fog + CONST_CAST(GLEW_WIN_specular_fog) = _glewSearchExtension("GL_WIN_specular_fog", extStart, extEnd); +#endif /* GL_WIN_specular_fog */ +#ifdef GL_WIN_swap_hint + CONST_CAST(GLEW_WIN_swap_hint) = _glewSearchExtension("GL_WIN_swap_hint", extStart, extEnd); + if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_WIN_swap_hint */ + + return GLEW_OK; +} + + +#if defined(_WIN32) + +#if !defined(GLEW_MX) + +PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL; + +PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL; +PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL; +PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL; +PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL; +PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL; +PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL; +PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL; +PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL; +PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL; + +PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL; +PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL; +PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL; +PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL; + +PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL; + +PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL; + +PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL; +PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL; + +PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL; +PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL; +PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL; +PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL; +PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL; + +PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL; +PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL; +PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL; + +PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL; +PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL; +PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL; + +PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL; +PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL; +PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL; +PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL; + +PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL; + +PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL; +PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL; + +PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL; +PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL; +PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL; +PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL; +PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL; + +PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL; +PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL; +PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL; + +PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL; +PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL; + +PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL; +PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL; + +PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL; +PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL; +PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL; +PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL; + +PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL; +PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL; +PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL; +PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL; +PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL; +PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL; +PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL; +PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL; +PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL; +PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL; +PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL; +PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL; + +PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL; +PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL; +PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL; +PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL; + +PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL; +PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL; +PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL; +PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL; + +PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL; +PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL; +PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL; +PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL; + +PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL; +PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL; +PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL; +PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL; +PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL; +PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL; +PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL; +PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL; + +PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL; + +PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL; +PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL; +PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL; +PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL; +PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL; + +PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL; +PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL; +PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL; + +PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL; +PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL; +PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL; +PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL; +PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL; +PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL; + +PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL; +PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL; + +PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL; +PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL; +PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL; +PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL; +PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL; + +PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL; +PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL; +PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL; +PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL; +PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL; +PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL; + +PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL; +PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL; +PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL; +PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL; +PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL; +PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL; +GLboolean __WGLEW_3DFX_multisample = GL_FALSE; +GLboolean __WGLEW_3DL_stereo_control = GL_FALSE; +GLboolean __WGLEW_AMD_gpu_association = GL_FALSE; +GLboolean __WGLEW_ARB_buffer_region = GL_FALSE; +GLboolean __WGLEW_ARB_create_context = GL_FALSE; +GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE; +GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE; +GLboolean __WGLEW_ARB_extensions_string = GL_FALSE; +GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __WGLEW_ARB_make_current_read = GL_FALSE; +GLboolean __WGLEW_ARB_multisample = GL_FALSE; +GLboolean __WGLEW_ARB_pbuffer = GL_FALSE; +GLboolean __WGLEW_ARB_pixel_format = GL_FALSE; +GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE; +GLboolean __WGLEW_ARB_render_texture = GL_FALSE; +GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE; +GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE; +GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE; +GLboolean __WGLEW_EXT_depth_float = GL_FALSE; +GLboolean __WGLEW_EXT_display_color_table = GL_FALSE; +GLboolean __WGLEW_EXT_extensions_string = GL_FALSE; +GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __WGLEW_EXT_make_current_read = GL_FALSE; +GLboolean __WGLEW_EXT_multisample = GL_FALSE; +GLboolean __WGLEW_EXT_pbuffer = GL_FALSE; +GLboolean __WGLEW_EXT_pixel_format = GL_FALSE; +GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE; +GLboolean __WGLEW_EXT_swap_control = GL_FALSE; +GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE; +GLboolean __WGLEW_I3D_gamma = GL_FALSE; +GLboolean __WGLEW_I3D_genlock = GL_FALSE; +GLboolean __WGLEW_I3D_image_buffer = GL_FALSE; +GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE; +GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE; +GLboolean __WGLEW_NV_DX_interop = GL_FALSE; +GLboolean __WGLEW_NV_copy_image = GL_FALSE; +GLboolean __WGLEW_NV_float_buffer = GL_FALSE; +GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE; +GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE; +GLboolean __WGLEW_NV_present_video = GL_FALSE; +GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE; +GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE; +GLboolean __WGLEW_NV_swap_group = GL_FALSE; +GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE; +GLboolean __WGLEW_NV_video_capture = GL_FALSE; +GLboolean __WGLEW_NV_video_output = GL_FALSE; +GLboolean __WGLEW_OML_sync_control = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef WGL_3DFX_multisample + +#endif /* WGL_3DFX_multisample */ + +#ifdef WGL_3DL_stereo_control + +static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r; + + return r; +} + +#endif /* WGL_3DL_stereo_control */ + +#ifdef WGL_AMD_gpu_association + +static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r; + r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r; + r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r; + r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r; + r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r; + r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r; + r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r; + r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r; + r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r; + + return r; +} + +#endif /* WGL_AMD_gpu_association */ + +#ifdef WGL_ARB_buffer_region + +static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r; + r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r; + r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r; + r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_buffer_region */ + +#ifdef WGL_ARB_create_context + +static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_create_context */ + +#ifdef WGL_ARB_create_context_profile + +#endif /* WGL_ARB_create_context_profile */ + +#ifdef WGL_ARB_create_context_robustness + +#endif /* WGL_ARB_create_context_robustness */ + +#ifdef WGL_ARB_extensions_string + +static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_extensions_string */ + +#ifdef WGL_ARB_framebuffer_sRGB + +#endif /* WGL_ARB_framebuffer_sRGB */ + +#ifdef WGL_ARB_make_current_read + +static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r; + r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_make_current_read */ + +#ifdef WGL_ARB_multisample + +#endif /* WGL_ARB_multisample */ + +#ifdef WGL_ARB_pbuffer + +static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r; + r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r; + r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r; + r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r; + r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_pbuffer */ + +#ifdef WGL_ARB_pixel_format + +static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r; + r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r; + r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_pixel_format */ + +#ifdef WGL_ARB_pixel_format_float + +#endif /* WGL_ARB_pixel_format_float */ + +#ifdef WGL_ARB_render_texture + +static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r; + r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r; + r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_render_texture */ + +#ifdef WGL_ATI_pixel_format_float + +#endif /* WGL_ATI_pixel_format_float */ + +#ifdef WGL_ATI_render_texture_rectangle + +#endif /* WGL_ATI_render_texture_rectangle */ + +#ifdef WGL_EXT_create_context_es2_profile + +#endif /* WGL_EXT_create_context_es2_profile */ + +#ifdef WGL_EXT_depth_float + +#endif /* WGL_EXT_depth_float */ + +#ifdef WGL_EXT_display_color_table + +static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r; + r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r; + r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r; + r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_display_color_table */ + +#ifdef WGL_EXT_extensions_string + +static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_extensions_string */ + +#ifdef WGL_EXT_framebuffer_sRGB + +#endif /* WGL_EXT_framebuffer_sRGB */ + +#ifdef WGL_EXT_make_current_read + +static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r; + r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_make_current_read */ + +#ifdef WGL_EXT_multisample + +#endif /* WGL_EXT_multisample */ + +#ifdef WGL_EXT_pbuffer + +static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r; + r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r; + r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r; + r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r; + r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_pbuffer */ + +#ifdef WGL_EXT_pixel_format + +static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r; + r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r; + r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_pixel_format */ + +#ifdef WGL_EXT_pixel_format_packed_float + +#endif /* WGL_EXT_pixel_format_packed_float */ + +#ifdef WGL_EXT_swap_control + +static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r; + r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_swap_control */ + +#ifdef WGL_I3D_digital_video_control + +static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r; + r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_digital_video_control */ + +#ifdef WGL_I3D_gamma + +static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r; + r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r; + r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r; + r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_gamma */ + +#ifdef WGL_I3D_genlock + +static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r; + r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r; + r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r; + r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r; + r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r; + r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r; + r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r; + r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r; + r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r; + r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r; + r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r; + r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_genlock */ + +#ifdef WGL_I3D_image_buffer + +static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r; + r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r; + r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r; + r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_image_buffer */ + +#ifdef WGL_I3D_swap_frame_lock + +static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r; + r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r; + r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r; + r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_swap_frame_lock */ + +#ifdef WGL_I3D_swap_frame_usage + +static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r; + r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r; + r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r; + r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_swap_frame_usage */ + +#ifdef WGL_NV_DX_interop + +static GLboolean _glewInit_WGL_NV_DX_interop (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r; + r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r; + r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r; + r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r; + r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r; + r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r; + r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r; + r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_DX_interop */ + +#ifdef WGL_NV_copy_image + +static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_copy_image */ + +#ifdef WGL_NV_float_buffer + +#endif /* WGL_NV_float_buffer */ + +#ifdef WGL_NV_gpu_affinity + +static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r; + r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r; + r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r; + r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r; + r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_gpu_affinity */ + +#ifdef WGL_NV_multisample_coverage + +#endif /* WGL_NV_multisample_coverage */ + +#ifdef WGL_NV_present_video + +static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r; + r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r; + r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_present_video */ + +#ifdef WGL_NV_render_depth_texture + +#endif /* WGL_NV_render_depth_texture */ + +#ifdef WGL_NV_render_texture_rectangle + +#endif /* WGL_NV_render_texture_rectangle */ + +#ifdef WGL_NV_swap_group + +static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r; + r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r; + r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r; + r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r; + r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r; + r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_swap_group */ + +#ifdef WGL_NV_vertex_array_range + +static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r; + r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_vertex_array_range */ + +#ifdef WGL_NV_video_capture + +static GLboolean _glewInit_WGL_NV_video_capture (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r; + r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r; + r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r; + r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r; + r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_video_capture */ + +#ifdef WGL_NV_video_output + +static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r; + r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r; + r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r; + r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r; + r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r; + r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_video_output */ + +#ifdef WGL_OML_sync_control + +static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r; + r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r; + r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r; + r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r; + r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r; + r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r; + + return r; +} + +#endif /* WGL_OML_sync_control */ + +/* ------------------------------------------------------------------------- */ + +static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL; +static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL; + +GLboolean wglewGetExtension (const char* name) +{ + const GLubyte* start; + const GLubyte* end; + if (_wglewGetExtensionsStringARB == NULL) + if (_wglewGetExtensionsStringEXT == NULL) + return GL_FALSE; + else + start = (const GLubyte*)_wglewGetExtensionsStringEXT(); + else + start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); + if (start == 0) + return GL_FALSE; + end = start + _glewStrLen(start); + return _glewSearchExtension(name, start, end); +} + +GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST) +{ + GLboolean crippled; + const GLubyte* extStart; + const GLubyte* extEnd; + /* find wgl extension string query functions */ + _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB"); + _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT"); + /* query wgl extension string */ + if (_wglewGetExtensionsStringARB == NULL) + if (_wglewGetExtensionsStringEXT == NULL) + extStart = (const GLubyte*)""; + else + extStart = (const GLubyte*)_wglewGetExtensionsStringEXT(); + else + extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); + extEnd = extStart + _glewStrLen(extStart); + /* initialize extensions */ + crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL; +#ifdef WGL_3DFX_multisample + CONST_CAST(WGLEW_3DFX_multisample) = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd); +#endif /* WGL_3DFX_multisample */ +#ifdef WGL_3DL_stereo_control + CONST_CAST(WGLEW_3DL_stereo_control) = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd); + if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_3DL_stereo_control */ +#ifdef WGL_AMD_gpu_association + CONST_CAST(WGLEW_AMD_gpu_association) = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd); + if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) CONST_CAST(WGLEW_AMD_gpu_association)= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_AMD_gpu_association */ +#ifdef WGL_ARB_buffer_region + CONST_CAST(WGLEW_ARB_buffer_region) = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_buffer_region */ +#ifdef WGL_ARB_create_context + CONST_CAST(WGLEW_ARB_create_context) = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_create_context */ +#ifdef WGL_ARB_create_context_profile + CONST_CAST(WGLEW_ARB_create_context_profile) = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd); +#endif /* WGL_ARB_create_context_profile */ +#ifdef WGL_ARB_create_context_robustness + CONST_CAST(WGLEW_ARB_create_context_robustness) = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd); +#endif /* WGL_ARB_create_context_robustness */ +#ifdef WGL_ARB_extensions_string + CONST_CAST(WGLEW_ARB_extensions_string) = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_extensions_string */ +#ifdef WGL_ARB_framebuffer_sRGB + CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd); +#endif /* WGL_ARB_framebuffer_sRGB */ +#ifdef WGL_ARB_make_current_read + CONST_CAST(WGLEW_ARB_make_current_read) = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_make_current_read */ +#ifdef WGL_ARB_multisample + CONST_CAST(WGLEW_ARB_multisample) = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd); +#endif /* WGL_ARB_multisample */ +#ifdef WGL_ARB_pbuffer + CONST_CAST(WGLEW_ARB_pbuffer) = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_pbuffer */ +#ifdef WGL_ARB_pixel_format + CONST_CAST(WGLEW_ARB_pixel_format) = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_pixel_format */ +#ifdef WGL_ARB_pixel_format_float + CONST_CAST(WGLEW_ARB_pixel_format_float) = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd); +#endif /* WGL_ARB_pixel_format_float */ +#ifdef WGL_ARB_render_texture + CONST_CAST(WGLEW_ARB_render_texture) = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd); + if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_render_texture */ +#ifdef WGL_ATI_pixel_format_float + CONST_CAST(WGLEW_ATI_pixel_format_float) = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd); +#endif /* WGL_ATI_pixel_format_float */ +#ifdef WGL_ATI_render_texture_rectangle + CONST_CAST(WGLEW_ATI_render_texture_rectangle) = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd); +#endif /* WGL_ATI_render_texture_rectangle */ +#ifdef WGL_EXT_create_context_es2_profile + CONST_CAST(WGLEW_EXT_create_context_es2_profile) = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd); +#endif /* WGL_EXT_create_context_es2_profile */ +#ifdef WGL_EXT_depth_float + CONST_CAST(WGLEW_EXT_depth_float) = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd); +#endif /* WGL_EXT_depth_float */ +#ifdef WGL_EXT_display_color_table + CONST_CAST(WGLEW_EXT_display_color_table) = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_display_color_table */ +#ifdef WGL_EXT_extensions_string + CONST_CAST(WGLEW_EXT_extensions_string) = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_extensions_string */ +#ifdef WGL_EXT_framebuffer_sRGB + CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd); +#endif /* WGL_EXT_framebuffer_sRGB */ +#ifdef WGL_EXT_make_current_read + CONST_CAST(WGLEW_EXT_make_current_read) = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_make_current_read */ +#ifdef WGL_EXT_multisample + CONST_CAST(WGLEW_EXT_multisample) = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd); +#endif /* WGL_EXT_multisample */ +#ifdef WGL_EXT_pbuffer + CONST_CAST(WGLEW_EXT_pbuffer) = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_pbuffer */ +#ifdef WGL_EXT_pixel_format + CONST_CAST(WGLEW_EXT_pixel_format) = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_pixel_format */ +#ifdef WGL_EXT_pixel_format_packed_float + CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd); +#endif /* WGL_EXT_pixel_format_packed_float */ +#ifdef WGL_EXT_swap_control + CONST_CAST(WGLEW_EXT_swap_control) = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd); + if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_swap_control */ +#ifdef WGL_I3D_digital_video_control + CONST_CAST(WGLEW_I3D_digital_video_control) = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_digital_video_control */ +#ifdef WGL_I3D_gamma + CONST_CAST(WGLEW_I3D_gamma) = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_gamma */ +#ifdef WGL_I3D_genlock + CONST_CAST(WGLEW_I3D_genlock) = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_genlock */ +#ifdef WGL_I3D_image_buffer + CONST_CAST(WGLEW_I3D_image_buffer) = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_image_buffer */ +#ifdef WGL_I3D_swap_frame_lock + CONST_CAST(WGLEW_I3D_swap_frame_lock) = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_swap_frame_lock */ +#ifdef WGL_I3D_swap_frame_usage + CONST_CAST(WGLEW_I3D_swap_frame_usage) = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd); + if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_swap_frame_usage */ +#ifdef WGL_NV_DX_interop + CONST_CAST(WGLEW_NV_DX_interop) = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd); + if (glewExperimental || WGLEW_NV_DX_interop|| crippled) CONST_CAST(WGLEW_NV_DX_interop)= !_glewInit_WGL_NV_DX_interop(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_DX_interop */ +#ifdef WGL_NV_copy_image + CONST_CAST(WGLEW_NV_copy_image) = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd); + if (glewExperimental || WGLEW_NV_copy_image|| crippled) CONST_CAST(WGLEW_NV_copy_image)= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_copy_image */ +#ifdef WGL_NV_float_buffer + CONST_CAST(WGLEW_NV_float_buffer) = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd); +#endif /* WGL_NV_float_buffer */ +#ifdef WGL_NV_gpu_affinity + CONST_CAST(WGLEW_NV_gpu_affinity) = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd); + if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_gpu_affinity */ +#ifdef WGL_NV_multisample_coverage + CONST_CAST(WGLEW_NV_multisample_coverage) = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd); +#endif /* WGL_NV_multisample_coverage */ +#ifdef WGL_NV_present_video + CONST_CAST(WGLEW_NV_present_video) = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd); + if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_present_video */ +#ifdef WGL_NV_render_depth_texture + CONST_CAST(WGLEW_NV_render_depth_texture) = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd); +#endif /* WGL_NV_render_depth_texture */ +#ifdef WGL_NV_render_texture_rectangle + CONST_CAST(WGLEW_NV_render_texture_rectangle) = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd); +#endif /* WGL_NV_render_texture_rectangle */ +#ifdef WGL_NV_swap_group + CONST_CAST(WGLEW_NV_swap_group) = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd); + if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_swap_group */ +#ifdef WGL_NV_vertex_array_range + CONST_CAST(WGLEW_NV_vertex_array_range) = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd); + if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_vertex_array_range */ +#ifdef WGL_NV_video_capture + CONST_CAST(WGLEW_NV_video_capture) = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd); + if (glewExperimental || WGLEW_NV_video_capture|| crippled) CONST_CAST(WGLEW_NV_video_capture)= !_glewInit_WGL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_video_capture */ +#ifdef WGL_NV_video_output + CONST_CAST(WGLEW_NV_video_output) = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd); + if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_video_output */ +#ifdef WGL_OML_sync_control + CONST_CAST(WGLEW_OML_sync_control) = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd); + if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_OML_sync_control */ + + return GLEW_OK; +} + +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) + +PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL; + +PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL; +PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL; +PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL; +PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL; +PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL; +PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL; +PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL; +PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL; +PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL; +PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL; +PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL; +PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL; +PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL; +PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL; +PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL; +PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL; +PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL; + +PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL; + +PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL; +PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL; +PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL; + +PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL; +PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL; +PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL; +PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL; + +PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL; + +PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL; +PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL; + +PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL; + +PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL; + +PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL; + +PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL; + +PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL; + +PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL; +PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL; + +PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL; + +PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL; +PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL; + +PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL; +PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL; +PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL; +PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL; +PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL; +PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL; + +PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL; +PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL; + +PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL; +PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL; +PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL; +PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL; +PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL; + +PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL; +PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL; +PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL; +PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL; +PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL; +PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL; + +PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL; +PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL; +PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL; +PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL; +PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL; + +PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL; +PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL; +PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL; +PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL; +PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL; +PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL; + +PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL; +PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL; +PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL; +PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL; +PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL; +PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL; +PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL; +PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL; + +PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL; +PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL; +PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL; +PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL; +PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL; + +PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL; +PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL; + +PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL; + +PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL; +PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL; +PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL; +PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL; +PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL; + +PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL; + +PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL; +PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL; + +PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL; + +PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL; +PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL; + +PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL; + +PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL; +PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL; + +#if !defined(GLEW_MX) + +GLboolean __GLXEW_VERSION_1_0 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_1 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_2 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_3 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_4 = GL_FALSE; +GLboolean __GLXEW_3DFX_multisample = GL_FALSE; +GLboolean __GLXEW_AMD_gpu_association = GL_FALSE; +GLboolean __GLXEW_ARB_create_context = GL_FALSE; +GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE; +GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE; +GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE; +GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE; +GLboolean __GLXEW_ARB_multisample = GL_FALSE; +GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE; +GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE; +GLboolean __GLXEW_ATI_render_texture = GL_FALSE; +GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE; +GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE; +GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLXEW_EXT_import_context = GL_FALSE; +GLboolean __GLXEW_EXT_scene_marker = GL_FALSE; +GLboolean __GLXEW_EXT_swap_control = GL_FALSE; +GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE; +GLboolean __GLXEW_EXT_visual_info = GL_FALSE; +GLboolean __GLXEW_EXT_visual_rating = GL_FALSE; +GLboolean __GLXEW_INTEL_swap_event = GL_FALSE; +GLboolean __GLXEW_MESA_agp_offset = GL_FALSE; +GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE; +GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE; +GLboolean __GLXEW_MESA_release_buffers = GL_FALSE; +GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE; +GLboolean __GLXEW_MESA_swap_control = GL_FALSE; +GLboolean __GLXEW_NV_copy_image = GL_FALSE; +GLboolean __GLXEW_NV_float_buffer = GL_FALSE; +GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE; +GLboolean __GLXEW_NV_present_video = GL_FALSE; +GLboolean __GLXEW_NV_swap_group = GL_FALSE; +GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE; +GLboolean __GLXEW_NV_video_capture = GL_FALSE; +GLboolean __GLXEW_NV_video_output = GL_FALSE; +GLboolean __GLXEW_OML_swap_method = GL_FALSE; +GLboolean __GLXEW_OML_sync_control = GL_FALSE; +GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE; +GLboolean __GLXEW_SGIS_color_range = GL_FALSE; +GLboolean __GLXEW_SGIS_multisample = GL_FALSE; +GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE; +GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE; +GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE; +GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE; +GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE; +GLboolean __GLXEW_SGIX_swap_group = GL_FALSE; +GLboolean __GLXEW_SGIX_video_resize = GL_FALSE; +GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE; +GLboolean __GLXEW_SGI_cushion = GL_FALSE; +GLboolean __GLXEW_SGI_make_current_read = GL_FALSE; +GLboolean __GLXEW_SGI_swap_control = GL_FALSE; +GLboolean __GLXEW_SGI_video_sync = GL_FALSE; +GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE; +GLboolean __GLXEW_SUN_video_resize = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef GLX_VERSION_1_2 + +static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r; + + return r; +} + +#endif /* GLX_VERSION_1_2 */ + +#ifdef GLX_VERSION_1_3 + +static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r; + r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r; + r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r; + r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r; + r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r; + r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r; + r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r; + r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r; + r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r; + r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r; + r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r; + r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r; + r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r; + r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r; + r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r; + r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r; + r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r; + + return r; +} + +#endif /* GLX_VERSION_1_3 */ + +#ifdef GLX_VERSION_1_4 + +#endif /* GLX_VERSION_1_4 */ + +#ifdef GLX_3DFX_multisample + +#endif /* GLX_3DFX_multisample */ + +#ifdef GLX_AMD_gpu_association + +#endif /* GLX_AMD_gpu_association */ + +#ifdef GLX_ARB_create_context + +static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r; + + return r; +} + +#endif /* GLX_ARB_create_context */ + +#ifdef GLX_ARB_create_context_profile + +#endif /* GLX_ARB_create_context_profile */ + +#ifdef GLX_ARB_create_context_robustness + +#endif /* GLX_ARB_create_context_robustness */ + +#ifdef GLX_ARB_fbconfig_float + +#endif /* GLX_ARB_fbconfig_float */ + +#ifdef GLX_ARB_framebuffer_sRGB + +#endif /* GLX_ARB_framebuffer_sRGB */ + +#ifdef GLX_ARB_get_proc_address + +#endif /* GLX_ARB_get_proc_address */ + +#ifdef GLX_ARB_multisample + +#endif /* GLX_ARB_multisample */ + +#ifdef GLX_ARB_vertex_buffer_object + +#endif /* GLX_ARB_vertex_buffer_object */ + +#ifdef GLX_ATI_pixel_format_float + +#endif /* GLX_ATI_pixel_format_float */ + +#ifdef GLX_ATI_render_texture + +static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r; + r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r; + r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r; + + return r; +} + +#endif /* GLX_ATI_render_texture */ + +#ifdef GLX_EXT_create_context_es2_profile + +#endif /* GLX_EXT_create_context_es2_profile */ + +#ifdef GLX_EXT_fbconfig_packed_float + +#endif /* GLX_EXT_fbconfig_packed_float */ + +#ifdef GLX_EXT_framebuffer_sRGB + +#endif /* GLX_EXT_framebuffer_sRGB */ + +#ifdef GLX_EXT_import_context + +static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r; + r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r; + r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r; + r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r; + + return r; +} + +#endif /* GLX_EXT_import_context */ + +#ifdef GLX_EXT_scene_marker + +#endif /* GLX_EXT_scene_marker */ + +#ifdef GLX_EXT_swap_control + +static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r; + + return r; +} + +#endif /* GLX_EXT_swap_control */ + +#ifdef GLX_EXT_texture_from_pixmap + +static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r; + r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r; + + return r; +} + +#endif /* GLX_EXT_texture_from_pixmap */ + +#ifdef GLX_EXT_visual_info + +#endif /* GLX_EXT_visual_info */ + +#ifdef GLX_EXT_visual_rating + +#endif /* GLX_EXT_visual_rating */ + +#ifdef GLX_INTEL_swap_event + +#endif /* GLX_INTEL_swap_event */ + +#ifdef GLX_MESA_agp_offset + +static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_agp_offset */ + +#ifdef GLX_MESA_copy_sub_buffer + +static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_copy_sub_buffer */ + +#ifdef GLX_MESA_pixmap_colormap + +static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_pixmap_colormap */ + +#ifdef GLX_MESA_release_buffers + +static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_release_buffers */ + +#ifdef GLX_MESA_set_3dfx_mode + +static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_set_3dfx_mode */ + +#ifdef GLX_MESA_swap_control + +static GLboolean _glewInit_GLX_MESA_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r; + r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_swap_control */ + +#ifdef GLX_NV_copy_image + +static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_copy_image */ + +#ifdef GLX_NV_float_buffer + +#endif /* GLX_NV_float_buffer */ + +#ifdef GLX_NV_multisample_coverage + +#endif /* GLX_NV_multisample_coverage */ + +#ifdef GLX_NV_present_video + +static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r; + r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_present_video */ + +#ifdef GLX_NV_swap_group + +static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r; + r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r; + r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r; + r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r; + r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r; + r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_swap_group */ + +#ifdef GLX_NV_vertex_array_range + +static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r; + r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_vertex_array_range */ + +#ifdef GLX_NV_video_capture + +static GLboolean _glewInit_GLX_NV_video_capture (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r; + r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r; + r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r; + r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r; + r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_video_capture */ + +#ifdef GLX_NV_video_output + +static GLboolean _glewInit_GLX_NV_video_output (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r; + r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r; + r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r; + r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r; + r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r; + r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_video_output */ + +#ifdef GLX_OML_swap_method + +#endif /* GLX_OML_swap_method */ + +#ifdef GLX_OML_sync_control + +static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r; + r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r; + r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r; + r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r; + r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r; + + return r; +} + +#endif /* GLX_OML_sync_control */ + +#ifdef GLX_SGIS_blended_overlay + +#endif /* GLX_SGIS_blended_overlay */ + +#ifdef GLX_SGIS_color_range + +#endif /* GLX_SGIS_color_range */ + +#ifdef GLX_SGIS_multisample + +#endif /* GLX_SGIS_multisample */ + +#ifdef GLX_SGIS_shared_multisample + +#endif /* GLX_SGIS_shared_multisample */ + +#ifdef GLX_SGIX_fbconfig + +static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r; + r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r; + r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r; + r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r; + r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r; + r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_fbconfig */ + +#ifdef GLX_SGIX_hyperpipe + +static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r; + r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r; + r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_hyperpipe */ + +#ifdef GLX_SGIX_pbuffer + +static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r; + r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r; + r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r; + r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r; + r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_pbuffer */ + +#ifdef GLX_SGIX_swap_barrier + +static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r; + r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_swap_barrier */ + +#ifdef GLX_SGIX_swap_group + +static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_swap_group */ + +#ifdef GLX_SGIX_video_resize + +static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r; + r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r; + r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r; + r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r; + r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_video_resize */ + +#ifdef GLX_SGIX_visual_select_group + +#endif /* GLX_SGIX_visual_select_group */ + +#ifdef GLX_SGI_cushion + +static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_cushion */ + +#ifdef GLX_SGI_make_current_read + +static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r; + r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_make_current_read */ + +#ifdef GLX_SGI_swap_control + +static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_swap_control */ + +#ifdef GLX_SGI_video_sync + +static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r; + r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_video_sync */ + +#ifdef GLX_SUN_get_transparent_index + +static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r; + + return r; +} + +#endif /* GLX_SUN_get_transparent_index */ + +#ifdef GLX_SUN_video_resize + +static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r; + r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r; + + return r; +} + +#endif /* GLX_SUN_video_resize */ + +/* ------------------------------------------------------------------------ */ + +GLboolean glxewGetExtension (const char* name) +{ + const GLubyte* start; + const GLubyte* end; + + if (glXGetCurrentDisplay == NULL) return GL_FALSE; + start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); + if (0 == start) return GL_FALSE; + end = start + _glewStrLen(start); + return _glewSearchExtension(name, start, end); +} + +GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST) +{ + int major, minor; + const GLubyte* extStart; + const GLubyte* extEnd; + /* initialize core GLX 1.2 */ + if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY; + /* initialize flags */ + CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE; + /* query GLX version */ + glXQueryVersion(glXGetCurrentDisplay(), &major, &minor); + if (major == 1 && minor <= 3) + { + switch (minor) + { + case 3: + CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE; + break; + case 2: + CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE; + CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE; + break; + default: + return GLEW_ERROR_GLX_VERSION_11_ONLY; + break; + } + } + /* query GLX extension string */ + extStart = 0; + if (glXGetCurrentDisplay != NULL) + extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); + if (extStart == 0) + extStart = (const GLubyte *)""; + extEnd = extStart + _glewStrLen(extStart); + /* initialize extensions */ +#ifdef GLX_VERSION_1_3 + if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_VERSION_1_3 */ +#ifdef GLX_3DFX_multisample + CONST_CAST(GLXEW_3DFX_multisample) = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd); +#endif /* GLX_3DFX_multisample */ +#ifdef GLX_AMD_gpu_association + CONST_CAST(GLXEW_AMD_gpu_association) = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd); +#endif /* GLX_AMD_gpu_association */ +#ifdef GLX_ARB_create_context + CONST_CAST(GLXEW_ARB_create_context) = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd); + if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_ARB_create_context */ +#ifdef GLX_ARB_create_context_profile + CONST_CAST(GLXEW_ARB_create_context_profile) = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd); +#endif /* GLX_ARB_create_context_profile */ +#ifdef GLX_ARB_create_context_robustness + CONST_CAST(GLXEW_ARB_create_context_robustness) = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd); +#endif /* GLX_ARB_create_context_robustness */ +#ifdef GLX_ARB_fbconfig_float + CONST_CAST(GLXEW_ARB_fbconfig_float) = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd); +#endif /* GLX_ARB_fbconfig_float */ +#ifdef GLX_ARB_framebuffer_sRGB + CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd); +#endif /* GLX_ARB_framebuffer_sRGB */ +#ifdef GLX_ARB_get_proc_address + CONST_CAST(GLXEW_ARB_get_proc_address) = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd); +#endif /* GLX_ARB_get_proc_address */ +#ifdef GLX_ARB_multisample + CONST_CAST(GLXEW_ARB_multisample) = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd); +#endif /* GLX_ARB_multisample */ +#ifdef GLX_ARB_vertex_buffer_object + CONST_CAST(GLXEW_ARB_vertex_buffer_object) = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd); +#endif /* GLX_ARB_vertex_buffer_object */ +#ifdef GLX_ATI_pixel_format_float + CONST_CAST(GLXEW_ATI_pixel_format_float) = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd); +#endif /* GLX_ATI_pixel_format_float */ +#ifdef GLX_ATI_render_texture + CONST_CAST(GLXEW_ATI_render_texture) = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd); + if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_ATI_render_texture */ +#ifdef GLX_EXT_create_context_es2_profile + CONST_CAST(GLXEW_EXT_create_context_es2_profile) = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd); +#endif /* GLX_EXT_create_context_es2_profile */ +#ifdef GLX_EXT_fbconfig_packed_float + CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd); +#endif /* GLX_EXT_fbconfig_packed_float */ +#ifdef GLX_EXT_framebuffer_sRGB + CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd); +#endif /* GLX_EXT_framebuffer_sRGB */ +#ifdef GLX_EXT_import_context + CONST_CAST(GLXEW_EXT_import_context) = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd); + if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_EXT_import_context */ +#ifdef GLX_EXT_scene_marker + CONST_CAST(GLXEW_EXT_scene_marker) = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd); +#endif /* GLX_EXT_scene_marker */ +#ifdef GLX_EXT_swap_control + CONST_CAST(GLXEW_EXT_swap_control) = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd); + if (glewExperimental || GLXEW_EXT_swap_control) CONST_CAST(GLXEW_EXT_swap_control) = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_EXT_swap_control */ +#ifdef GLX_EXT_texture_from_pixmap + CONST_CAST(GLXEW_EXT_texture_from_pixmap) = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd); + if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_EXT_texture_from_pixmap */ +#ifdef GLX_EXT_visual_info + CONST_CAST(GLXEW_EXT_visual_info) = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd); +#endif /* GLX_EXT_visual_info */ +#ifdef GLX_EXT_visual_rating + CONST_CAST(GLXEW_EXT_visual_rating) = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd); +#endif /* GLX_EXT_visual_rating */ +#ifdef GLX_INTEL_swap_event + CONST_CAST(GLXEW_INTEL_swap_event) = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd); +#endif /* GLX_INTEL_swap_event */ +#ifdef GLX_MESA_agp_offset + CONST_CAST(GLXEW_MESA_agp_offset) = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_agp_offset */ +#ifdef GLX_MESA_copy_sub_buffer + CONST_CAST(GLXEW_MESA_copy_sub_buffer) = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_copy_sub_buffer */ +#ifdef GLX_MESA_pixmap_colormap + CONST_CAST(GLXEW_MESA_pixmap_colormap) = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_pixmap_colormap */ +#ifdef GLX_MESA_release_buffers + CONST_CAST(GLXEW_MESA_release_buffers) = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_release_buffers */ +#ifdef GLX_MESA_set_3dfx_mode + CONST_CAST(GLXEW_MESA_set_3dfx_mode) = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_set_3dfx_mode */ +#ifdef GLX_MESA_swap_control + CONST_CAST(GLXEW_MESA_swap_control) = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd); + if (glewExperimental || GLXEW_MESA_swap_control) CONST_CAST(GLXEW_MESA_swap_control) = !_glewInit_GLX_MESA_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_swap_control */ +#ifdef GLX_NV_copy_image + CONST_CAST(GLXEW_NV_copy_image) = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd); + if (glewExperimental || GLXEW_NV_copy_image) CONST_CAST(GLXEW_NV_copy_image) = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_copy_image */ +#ifdef GLX_NV_float_buffer + CONST_CAST(GLXEW_NV_float_buffer) = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd); +#endif /* GLX_NV_float_buffer */ +#ifdef GLX_NV_multisample_coverage + CONST_CAST(GLXEW_NV_multisample_coverage) = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd); +#endif /* GLX_NV_multisample_coverage */ +#ifdef GLX_NV_present_video + CONST_CAST(GLXEW_NV_present_video) = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd); + if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_present_video */ +#ifdef GLX_NV_swap_group + CONST_CAST(GLXEW_NV_swap_group) = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd); + if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_swap_group */ +#ifdef GLX_NV_vertex_array_range + CONST_CAST(GLXEW_NV_vertex_array_range) = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd); + if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_vertex_array_range */ +#ifdef GLX_NV_video_capture + CONST_CAST(GLXEW_NV_video_capture) = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd); + if (glewExperimental || GLXEW_NV_video_capture) CONST_CAST(GLXEW_NV_video_capture) = !_glewInit_GLX_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_video_capture */ +#ifdef GLX_NV_video_output + CONST_CAST(GLXEW_NV_video_output) = _glewSearchExtension("GLX_NV_video_output", extStart, extEnd); + if (glewExperimental || GLXEW_NV_video_output) CONST_CAST(GLXEW_NV_video_output) = !_glewInit_GLX_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_video_output */ +#ifdef GLX_OML_swap_method + CONST_CAST(GLXEW_OML_swap_method) = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd); +#endif /* GLX_OML_swap_method */ +#ifdef GLX_OML_sync_control + CONST_CAST(GLXEW_OML_sync_control) = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd); + if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_OML_sync_control */ +#ifdef GLX_SGIS_blended_overlay + CONST_CAST(GLXEW_SGIS_blended_overlay) = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd); +#endif /* GLX_SGIS_blended_overlay */ +#ifdef GLX_SGIS_color_range + CONST_CAST(GLXEW_SGIS_color_range) = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd); +#endif /* GLX_SGIS_color_range */ +#ifdef GLX_SGIS_multisample + CONST_CAST(GLXEW_SGIS_multisample) = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd); +#endif /* GLX_SGIS_multisample */ +#ifdef GLX_SGIS_shared_multisample + CONST_CAST(GLXEW_SGIS_shared_multisample) = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd); +#endif /* GLX_SGIS_shared_multisample */ +#ifdef GLX_SGIX_fbconfig + CONST_CAST(GLXEW_SGIX_fbconfig) = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_fbconfig */ +#ifdef GLX_SGIX_hyperpipe + CONST_CAST(GLXEW_SGIX_hyperpipe) = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_hyperpipe */ +#ifdef GLX_SGIX_pbuffer + CONST_CAST(GLXEW_SGIX_pbuffer) = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_pbuffer */ +#ifdef GLX_SGIX_swap_barrier + CONST_CAST(GLXEW_SGIX_swap_barrier) = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_swap_barrier */ +#ifdef GLX_SGIX_swap_group + CONST_CAST(GLXEW_SGIX_swap_group) = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_swap_group */ +#ifdef GLX_SGIX_video_resize + CONST_CAST(GLXEW_SGIX_video_resize) = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd); + if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_video_resize */ +#ifdef GLX_SGIX_visual_select_group + CONST_CAST(GLXEW_SGIX_visual_select_group) = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd); +#endif /* GLX_SGIX_visual_select_group */ +#ifdef GLX_SGI_cushion + CONST_CAST(GLXEW_SGI_cushion) = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd); + if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_cushion */ +#ifdef GLX_SGI_make_current_read + CONST_CAST(GLXEW_SGI_make_current_read) = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd); + if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_make_current_read */ +#ifdef GLX_SGI_swap_control + CONST_CAST(GLXEW_SGI_swap_control) = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd); + if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_swap_control */ +#ifdef GLX_SGI_video_sync + CONST_CAST(GLXEW_SGI_video_sync) = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd); + if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_video_sync */ +#ifdef GLX_SUN_get_transparent_index + CONST_CAST(GLXEW_SUN_get_transparent_index) = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd); + if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SUN_get_transparent_index */ +#ifdef GLX_SUN_video_resize + CONST_CAST(GLXEW_SUN_video_resize) = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd); + if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SUN_video_resize */ + + return GLEW_OK; +} + +#endif /* !__APPLE__ || GLEW_APPLE_GLX */ + +/* ------------------------------------------------------------------------ */ + +const GLubyte* glewGetErrorString (GLenum error) +{ + static const GLubyte* _glewErrorString[] = + { + (const GLubyte*)"No error", + (const GLubyte*)"Missing GL version", + (const GLubyte*)"GL 1.1 and up are not supported", + (const GLubyte*)"GLX 1.2 and up are not supported", + (const GLubyte*)"Unknown error" + }; + const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1; + return _glewErrorString[(int)error > max_error ? max_error : (int)error]; +} + +const GLubyte* glewGetString (GLenum name) +{ + static const GLubyte* _glewString[] = + { + (const GLubyte*)NULL, + (const GLubyte*)"1.7.0", + (const GLubyte*)"1", + (const GLubyte*)"7", + (const GLubyte*)"0" + }; + const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; + return _glewString[(int)name > max_string ? 0 : (int)name]; +} + +/* ------------------------------------------------------------------------ */ + +GLboolean glewExperimental = GL_FALSE; + +#if !defined(GLEW_MX) + +#if defined(_WIN32) +extern GLenum wglewContextInit (void); +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */ +extern GLenum glxewContextInit (void); +#endif /* _WIN32 */ + +GLenum glewInit () +{ + GLenum r; + if ( (r = glewContextInit()) ) return r; +#if defined(_WIN32) + return wglewContextInit(); +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */ + return glxewContextInit(); +#else + return r; +#endif /* _WIN32 */ +} + +#endif /* !GLEW_MX */ +#ifdef GLEW_MX +GLboolean glewContextIsSupported (const GLEWContext* ctx, const char* name) +#else +GLboolean glewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) + { +#ifdef GL_VERSION_1_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) + { + ret = GLEW_VERSION_1_2; + continue; + } +#endif +#ifdef GL_VERSION_1_2_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5)) + { + ret = GLEW_VERSION_1_2_1; + continue; + } +#endif +#ifdef GL_VERSION_1_3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) + { + ret = GLEW_VERSION_1_3; + continue; + } +#endif +#ifdef GL_VERSION_1_4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) + { + ret = GLEW_VERSION_1_4; + continue; + } +#endif +#ifdef GL_VERSION_1_5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3)) + { + ret = GLEW_VERSION_1_5; + continue; + } +#endif +#ifdef GL_VERSION_2_0 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3)) + { + ret = GLEW_VERSION_2_0; + continue; + } +#endif +#ifdef GL_VERSION_2_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3)) + { + ret = GLEW_VERSION_2_1; + continue; + } +#endif +#ifdef GL_VERSION_3_0 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3)) + { + ret = GLEW_VERSION_3_0; + continue; + } +#endif +#ifdef GL_VERSION_3_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3)) + { + ret = GLEW_VERSION_3_1; + continue; + } +#endif +#ifdef GL_VERSION_3_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3)) + { + ret = GLEW_VERSION_3_2; + continue; + } +#endif +#ifdef GL_VERSION_3_3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3)) + { + ret = GLEW_VERSION_3_3; + continue; + } +#endif +#ifdef GL_VERSION_4_0 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3)) + { + ret = GLEW_VERSION_4_0; + continue; + } +#endif +#ifdef GL_VERSION_4_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3)) + { + ret = GLEW_VERSION_4_1; + continue; + } +#endif +#ifdef GL_VERSION_4_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3)) + { + ret = GLEW_VERSION_4_2; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef GL_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_3DFX_multisample; + continue; + } +#endif +#ifdef GL_3DFX_tbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7)) + { + ret = GLEW_3DFX_tbuffer; + continue; + } +#endif +#ifdef GL_3DFX_texture_compression_FXT1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24)) + { + ret = GLEW_3DFX_texture_compression_FXT1; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) + { +#ifdef GL_AMD_blend_minmax_factor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19)) + { + ret = GLEW_AMD_blend_minmax_factor; + continue; + } +#endif +#ifdef GL_AMD_conservative_depth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) + { + ret = GLEW_AMD_conservative_depth; + continue; + } +#endif +#ifdef GL_AMD_debug_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12)) + { + ret = GLEW_AMD_debug_output; + continue; + } +#endif +#ifdef GL_AMD_depth_clamp_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20)) + { + ret = GLEW_AMD_depth_clamp_separate; + continue; + } +#endif +#ifdef GL_AMD_draw_buffers_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18)) + { + ret = GLEW_AMD_draw_buffers_blend; + continue; + } +#endif +#ifdef GL_AMD_multi_draw_indirect + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19)) + { + ret = GLEW_AMD_multi_draw_indirect; + continue; + } +#endif +#ifdef GL_AMD_name_gen_delete + if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15)) + { + ret = GLEW_AMD_name_gen_delete; + continue; + } +#endif +#ifdef GL_AMD_performance_monitor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19)) + { + ret = GLEW_AMD_performance_monitor; + continue; + } +#endif +#ifdef GL_AMD_sample_positions + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16)) + { + ret = GLEW_AMD_sample_positions; + continue; + } +#endif +#ifdef GL_AMD_seamless_cubemap_per_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28)) + { + ret = GLEW_AMD_seamless_cubemap_per_texture; + continue; + } +#endif +#ifdef GL_AMD_shader_stencil_export + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21)) + { + ret = GLEW_AMD_shader_stencil_export; + continue; + } +#endif +#ifdef GL_AMD_texture_texture4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16)) + { + ret = GLEW_AMD_texture_texture4; + continue; + } +#endif +#ifdef GL_AMD_transform_feedback3_lines_triangles + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35)) + { + ret = GLEW_AMD_transform_feedback3_lines_triangles; + continue; + } +#endif +#ifdef GL_AMD_vertex_shader_tessellator + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25)) + { + ret = GLEW_AMD_vertex_shader_tessellator; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6)) + { +#ifdef GL_APPLE_aux_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17)) + { + ret = GLEW_APPLE_aux_depth_stencil; + continue; + } +#endif +#ifdef GL_APPLE_client_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14)) + { + ret = GLEW_APPLE_client_storage; + continue; + } +#endif +#ifdef GL_APPLE_element_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) + { + ret = GLEW_APPLE_element_array; + continue; + } +#endif +#ifdef GL_APPLE_fence + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) + { + ret = GLEW_APPLE_fence; + continue; + } +#endif +#ifdef GL_APPLE_float_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12)) + { + ret = GLEW_APPLE_float_pixels; + continue; + } +#endif +#ifdef GL_APPLE_flush_buffer_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18)) + { + ret = GLEW_APPLE_flush_buffer_range; + continue; + } +#endif +#ifdef GL_APPLE_object_purgeable + if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16)) + { + ret = GLEW_APPLE_object_purgeable; + continue; + } +#endif +#ifdef GL_APPLE_pixel_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12)) + { + ret = GLEW_APPLE_pixel_buffer; + continue; + } +#endif +#ifdef GL_APPLE_rgb_422 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7)) + { + ret = GLEW_APPLE_rgb_422; + continue; + } +#endif +#ifdef GL_APPLE_row_bytes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9)) + { + ret = GLEW_APPLE_row_bytes; + continue; + } +#endif +#ifdef GL_APPLE_specular_vector + if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15)) + { + ret = GLEW_APPLE_specular_vector; + continue; + } +#endif +#ifdef GL_APPLE_texture_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) + { + ret = GLEW_APPLE_texture_range; + continue; + } +#endif +#ifdef GL_APPLE_transform_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14)) + { + ret = GLEW_APPLE_transform_hint; + continue; + } +#endif +#ifdef GL_APPLE_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_APPLE_vertex_array_object; + continue; + } +#endif +#ifdef GL_APPLE_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLEW_APPLE_vertex_array_range; + continue; + } +#endif +#ifdef GL_APPLE_vertex_program_evaluators + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25)) + { + ret = GLEW_APPLE_vertex_program_evaluators; + continue; + } +#endif +#ifdef GL_APPLE_ycbcr_422 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9)) + { + ret = GLEW_APPLE_ycbcr_422; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef GL_ARB_ES2_compatibility + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17)) + { + ret = GLEW_ARB_ES2_compatibility; + continue; + } +#endif +#ifdef GL_ARB_base_instance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13)) + { + ret = GLEW_ARB_base_instance; + continue; + } +#endif +#ifdef GL_ARB_blend_func_extended + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19)) + { + ret = GLEW_ARB_blend_func_extended; + continue; + } +#endif +#ifdef GL_ARB_cl_event + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8)) + { + ret = GLEW_ARB_cl_event; + continue; + } +#endif +#ifdef GL_ARB_color_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18)) + { + ret = GLEW_ARB_color_buffer_float; + continue; + } +#endif +#ifdef GL_ARB_compatibility + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13)) + { + ret = GLEW_ARB_compatibility; + continue; + } +#endif +#ifdef GL_ARB_compressed_texture_pixel_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32)) + { + ret = GLEW_ARB_compressed_texture_pixel_storage; + continue; + } +#endif +#ifdef GL_ARB_conservative_depth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) + { + ret = GLEW_ARB_conservative_depth; + continue; + } +#endif +#ifdef GL_ARB_copy_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) + { + ret = GLEW_ARB_copy_buffer; + continue; + } +#endif +#ifdef GL_ARB_debug_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12)) + { + ret = GLEW_ARB_debug_output; + continue; + } +#endif +#ifdef GL_ARB_depth_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) + { + ret = GLEW_ARB_depth_buffer_float; + continue; + } +#endif +#ifdef GL_ARB_depth_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11)) + { + ret = GLEW_ARB_depth_clamp; + continue; + } +#endif +#ifdef GL_ARB_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) + { + ret = GLEW_ARB_depth_texture; + continue; + } +#endif +#ifdef GL_ARB_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_ARB_draw_buffers; + continue; + } +#endif +#ifdef GL_ARB_draw_buffers_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18)) + { + ret = GLEW_ARB_draw_buffers_blend; + continue; + } +#endif +#ifdef GL_ARB_draw_elements_base_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25)) + { + ret = GLEW_ARB_draw_elements_base_vertex; + continue; + } +#endif +#ifdef GL_ARB_draw_indirect + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13)) + { + ret = GLEW_ARB_draw_indirect; + continue; + } +#endif +#ifdef GL_ARB_draw_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) + { + ret = GLEW_ARB_draw_instanced; + continue; + } +#endif +#ifdef GL_ARB_explicit_attrib_location + if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24)) + { + ret = GLEW_ARB_explicit_attrib_location; + continue; + } +#endif +#ifdef GL_ARB_fragment_coord_conventions + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26)) + { + ret = GLEW_ARB_fragment_coord_conventions; + continue; + } +#endif +#ifdef GL_ARB_fragment_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) + { + ret = GLEW_ARB_fragment_program; + continue; + } +#endif +#ifdef GL_ARB_fragment_program_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23)) + { + ret = GLEW_ARB_fragment_program_shadow; + continue; + } +#endif +#ifdef GL_ARB_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) + { + ret = GLEW_ARB_fragment_shader; + continue; + } +#endif +#ifdef GL_ARB_framebuffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) + { + ret = GLEW_ARB_framebuffer_object; + continue; + } +#endif +#ifdef GL_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef GL_ARB_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_ARB_geometry_shader4; + continue; + } +#endif +#ifdef GL_ARB_get_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18)) + { + ret = GLEW_ARB_get_program_binary; + continue; + } +#endif +#ifdef GL_ARB_gpu_shader5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) + { + ret = GLEW_ARB_gpu_shader5; + continue; + } +#endif +#ifdef GL_ARB_gpu_shader_fp64 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15)) + { + ret = GLEW_ARB_gpu_shader_fp64; + continue; + } +#endif +#ifdef GL_ARB_half_float_pixel + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16)) + { + ret = GLEW_ARB_half_float_pixel; + continue; + } +#endif +#ifdef GL_ARB_half_float_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17)) + { + ret = GLEW_ARB_half_float_vertex; + continue; + } +#endif +#ifdef GL_ARB_imaging + if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7)) + { + ret = GLEW_ARB_imaging; + continue; + } +#endif +#ifdef GL_ARB_instanced_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) + { + ret = GLEW_ARB_instanced_arrays; + continue; + } +#endif +#ifdef GL_ARB_internalformat_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20)) + { + ret = GLEW_ARB_internalformat_query; + continue; + } +#endif +#ifdef GL_ARB_map_buffer_alignment + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20)) + { + ret = GLEW_ARB_map_buffer_alignment; + continue; + } +#endif +#ifdef GL_ARB_map_buffer_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16)) + { + ret = GLEW_ARB_map_buffer_range; + continue; + } +#endif +#ifdef GL_ARB_matrix_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14)) + { + ret = GLEW_ARB_matrix_palette; + continue; + } +#endif +#ifdef GL_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_ARB_multisample; + continue; + } +#endif +#ifdef GL_ARB_multitexture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12)) + { + ret = GLEW_ARB_multitexture; + continue; + } +#endif +#ifdef GL_ARB_occlusion_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) + { + ret = GLEW_ARB_occlusion_query; + continue; + } +#endif +#ifdef GL_ARB_occlusion_query2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16)) + { + ret = GLEW_ARB_occlusion_query2; + continue; + } +#endif +#ifdef GL_ARB_pixel_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) + { + ret = GLEW_ARB_pixel_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_point_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) + { + ret = GLEW_ARB_point_parameters; + continue; + } +#endif +#ifdef GL_ARB_point_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) + { + ret = GLEW_ARB_point_sprite; + continue; + } +#endif +#ifdef GL_ARB_provoking_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) + { + ret = GLEW_ARB_provoking_vertex; + continue; + } +#endif +#ifdef GL_ARB_robustness + if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10)) + { + ret = GLEW_ARB_robustness; + continue; + } +#endif +#ifdef GL_ARB_sample_shading + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14)) + { + ret = GLEW_ARB_sample_shading; + continue; + } +#endif +#ifdef GL_ARB_sampler_objects + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15)) + { + ret = GLEW_ARB_sampler_objects; + continue; + } +#endif +#ifdef GL_ARB_seamless_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17)) + { + ret = GLEW_ARB_seamless_cube_map; + continue; + } +#endif +#ifdef GL_ARB_separate_shader_objects + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) + { + ret = GLEW_ARB_separate_shader_objects; + continue; + } +#endif +#ifdef GL_ARB_shader_atomic_counters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22)) + { + ret = GLEW_ARB_shader_atomic_counters; + continue; + } +#endif +#ifdef GL_ARB_shader_bit_encoding + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19)) + { + ret = GLEW_ARB_shader_bit_encoding; + continue; + } +#endif +#ifdef GL_ARB_shader_image_load_store + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23)) + { + ret = GLEW_ARB_shader_image_load_store; + continue; + } +#endif +#ifdef GL_ARB_shader_objects + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14)) + { + ret = GLEW_ARB_shader_objects; + continue; + } +#endif +#ifdef GL_ARB_shader_precision + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16)) + { + ret = GLEW_ARB_shader_precision; + continue; + } +#endif +#ifdef GL_ARB_shader_stencil_export + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21)) + { + ret = GLEW_ARB_shader_stencil_export; + continue; + } +#endif +#ifdef GL_ARB_shader_subroutine + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17)) + { + ret = GLEW_ARB_shader_subroutine; + continue; + } +#endif +#ifdef GL_ARB_shader_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) + { + ret = GLEW_ARB_shader_texture_lod; + continue; + } +#endif +#ifdef GL_ARB_shading_language_100 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20)) + { + ret = GLEW_ARB_shading_language_100; + continue; + } +#endif +#ifdef GL_ARB_shading_language_420pack + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24)) + { + ret = GLEW_ARB_shading_language_420pack; + continue; + } +#endif +#ifdef GL_ARB_shading_language_include + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24)) + { + ret = GLEW_ARB_shading_language_include; + continue; + } +#endif +#ifdef GL_ARB_shading_language_packing + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24)) + { + ret = GLEW_ARB_shading_language_packing; + continue; + } +#endif +#ifdef GL_ARB_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) + { + ret = GLEW_ARB_shadow; + continue; + } +#endif +#ifdef GL_ARB_shadow_ambient + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) + { + ret = GLEW_ARB_shadow_ambient; + continue; + } +#endif +#ifdef GL_ARB_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4)) + { + ret = GLEW_ARB_sync; + continue; + } +#endif +#ifdef GL_ARB_tessellation_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19)) + { + ret = GLEW_ARB_tessellation_shader; + continue; + } +#endif +#ifdef GL_ARB_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_ARB_texture_border_clamp; + continue; + } +#endif +#ifdef GL_ARB_texture_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) + { + ret = GLEW_ARB_texture_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_texture_buffer_object_rgb32 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27)) + { + ret = GLEW_ARB_texture_buffer_object_rgb32; + continue; + } +#endif +#ifdef GL_ARB_texture_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19)) + { + ret = GLEW_ARB_texture_compression; + continue; + } +#endif +#ifdef GL_ARB_texture_compression_bptc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24)) + { + ret = GLEW_ARB_texture_compression_bptc; + continue; + } +#endif +#ifdef GL_ARB_texture_compression_rgtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) + { + ret = GLEW_ARB_texture_compression_rgtc; + continue; + } +#endif +#ifdef GL_ARB_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) + { + ret = GLEW_ARB_texture_cube_map; + continue; + } +#endif +#ifdef GL_ARB_texture_cube_map_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22)) + { + ret = GLEW_ARB_texture_cube_map_array; + continue; + } +#endif +#ifdef GL_ARB_texture_env_add + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) + { + ret = GLEW_ARB_texture_env_add; + continue; + } +#endif +#ifdef GL_ARB_texture_env_combine + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) + { + ret = GLEW_ARB_texture_env_combine; + continue; + } +#endif +#ifdef GL_ARB_texture_env_crossbar + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20)) + { + ret = GLEW_ARB_texture_env_crossbar; + continue; + } +#endif +#ifdef GL_ARB_texture_env_dot3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) + { + ret = GLEW_ARB_texture_env_dot3; + continue; + } +#endif +#ifdef GL_ARB_texture_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) + { + ret = GLEW_ARB_texture_float; + continue; + } +#endif +#ifdef GL_ARB_texture_gather + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14)) + { + ret = GLEW_ARB_texture_gather; + continue; + } +#endif +#ifdef GL_ARB_texture_mirrored_repeat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) + { + ret = GLEW_ARB_texture_mirrored_repeat; + continue; + } +#endif +#ifdef GL_ARB_texture_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19)) + { + ret = GLEW_ARB_texture_multisample; + continue; + } +#endif +#ifdef GL_ARB_texture_non_power_of_two + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24)) + { + ret = GLEW_ARB_texture_non_power_of_two; + continue; + } +#endif +#ifdef GL_ARB_texture_query_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17)) + { + ret = GLEW_ARB_texture_query_lod; + continue; + } +#endif +#ifdef GL_ARB_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_ARB_texture_rectangle; + continue; + } +#endif +#ifdef GL_ARB_texture_rg + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10)) + { + ret = GLEW_ARB_texture_rg; + continue; + } +#endif +#ifdef GL_ARB_texture_rgb10_a2ui + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18)) + { + ret = GLEW_ARB_texture_rgb10_a2ui; + continue; + } +#endif +#ifdef GL_ARB_texture_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15)) + { + ret = GLEW_ARB_texture_storage; + continue; + } +#endif +#ifdef GL_ARB_texture_swizzle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) + { + ret = GLEW_ARB_texture_swizzle; + continue; + } +#endif +#ifdef GL_ARB_timer_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) + { + ret = GLEW_ARB_timer_query; + continue; + } +#endif +#ifdef GL_ARB_transform_feedback2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19)) + { + ret = GLEW_ARB_transform_feedback2; + continue; + } +#endif +#ifdef GL_ARB_transform_feedback3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19)) + { + ret = GLEW_ARB_transform_feedback3; + continue; + } +#endif +#ifdef GL_ARB_transform_feedback_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28)) + { + ret = GLEW_ARB_transform_feedback_instanced; + continue; + } +#endif +#ifdef GL_ARB_transpose_matrix + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16)) + { + ret = GLEW_ARB_transpose_matrix; + continue; + } +#endif +#ifdef GL_ARB_uniform_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21)) + { + ret = GLEW_ARB_uniform_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_vertex_array_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17)) + { + ret = GLEW_ARB_vertex_array_bgra; + continue; + } +#endif +#ifdef GL_ARB_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_ARB_vertex_array_object; + continue; + } +#endif +#ifdef GL_ARB_vertex_attrib_64bit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19)) + { + ret = GLEW_ARB_vertex_attrib_64bit; + continue; + } +#endif +#ifdef GL_ARB_vertex_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12)) + { + ret = GLEW_ARB_vertex_blend; + continue; + } +#endif +#ifdef GL_ARB_vertex_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20)) + { + ret = GLEW_ARB_vertex_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_vertex_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) + { + ret = GLEW_ARB_vertex_program; + continue; + } +#endif +#ifdef GL_ARB_vertex_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) + { + ret = GLEW_ARB_vertex_shader; + continue; + } +#endif +#ifdef GL_ARB_vertex_type_2_10_10_10_rev + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26)) + { + ret = GLEW_ARB_vertex_type_2_10_10_10_rev; + continue; + } +#endif +#ifdef GL_ARB_viewport_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14)) + { + ret = GLEW_ARB_viewport_array; + continue; + } +#endif +#ifdef GL_ARB_window_pos + if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) + { + ret = GLEW_ARB_window_pos; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5)) + { +#ifdef GL_ATIX_point_sprites + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13)) + { + ret = GLEW_ATIX_point_sprites; + continue; + } +#endif +#ifdef GL_ATIX_texture_env_combine3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) + { + ret = GLEW_ATIX_texture_env_combine3; + continue; + } +#endif +#ifdef GL_ATIX_texture_env_route + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17)) + { + ret = GLEW_ATIX_texture_env_route; + continue; + } +#endif +#ifdef GL_ATIX_vertex_shader_output_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31)) + { + ret = GLEW_ATIX_vertex_shader_output_point_size; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef GL_ATI_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_ATI_draw_buffers; + continue; + } +#endif +#ifdef GL_ATI_element_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) + { + ret = GLEW_ATI_element_array; + continue; + } +#endif +#ifdef GL_ATI_envmap_bumpmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14)) + { + ret = GLEW_ATI_envmap_bumpmap; + continue; + } +#endif +#ifdef GL_ATI_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) + { + ret = GLEW_ATI_fragment_shader; + continue; + } +#endif +#ifdef GL_ATI_map_object_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17)) + { + ret = GLEW_ATI_map_object_buffer; + continue; + } +#endif +#ifdef GL_ATI_meminfo + if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7)) + { + ret = GLEW_ATI_meminfo; + continue; + } +#endif +#ifdef GL_ATI_pn_triangles + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12)) + { + ret = GLEW_ATI_pn_triangles; + continue; + } +#endif +#ifdef GL_ATI_separate_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16)) + { + ret = GLEW_ATI_separate_stencil; + continue; + } +#endif +#ifdef GL_ATI_shader_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) + { + ret = GLEW_ATI_shader_texture_lod; + continue; + } +#endif +#ifdef GL_ATI_text_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20)) + { + ret = GLEW_ATI_text_fragment_shader; + continue; + } +#endif +#ifdef GL_ATI_texture_compression_3dc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23)) + { + ret = GLEW_ATI_texture_compression_3dc; + continue; + } +#endif +#ifdef GL_ATI_texture_env_combine3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) + { + ret = GLEW_ATI_texture_env_combine3; + continue; + } +#endif +#ifdef GL_ATI_texture_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) + { + ret = GLEW_ATI_texture_float; + continue; + } +#endif +#ifdef GL_ATI_texture_mirror_once + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19)) + { + ret = GLEW_ATI_texture_mirror_once; + continue; + } +#endif +#ifdef GL_ATI_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_ATI_vertex_array_object; + continue; + } +#endif +#ifdef GL_ATI_vertex_attrib_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26)) + { + ret = GLEW_ATI_vertex_attrib_array_object; + continue; + } +#endif +#ifdef GL_ATI_vertex_streams + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14)) + { + ret = GLEW_ATI_vertex_streams; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef GL_EXT_422_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10)) + { + ret = GLEW_EXT_422_pixels; + continue; + } +#endif +#ifdef GL_EXT_Cg_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9)) + { + ret = GLEW_EXT_Cg_shader; + continue; + } +#endif +#ifdef GL_EXT_abgr + if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4)) + { + ret = GLEW_EXT_abgr; + continue; + } +#endif +#ifdef GL_EXT_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4)) + { + ret = GLEW_EXT_bgra; + continue; + } +#endif +#ifdef GL_EXT_bindable_uniform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16)) + { + ret = GLEW_EXT_bindable_uniform; + continue; + } +#endif +#ifdef GL_EXT_blend_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11)) + { + ret = GLEW_EXT_blend_color; + continue; + } +#endif +#ifdef GL_EXT_blend_equation_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23)) + { + ret = GLEW_EXT_blend_equation_separate; + continue; + } +#endif +#ifdef GL_EXT_blend_func_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19)) + { + ret = GLEW_EXT_blend_func_separate; + continue; + } +#endif +#ifdef GL_EXT_blend_logic_op + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14)) + { + ret = GLEW_EXT_blend_logic_op; + continue; + } +#endif +#ifdef GL_EXT_blend_minmax + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12)) + { + ret = GLEW_EXT_blend_minmax; + continue; + } +#endif +#ifdef GL_EXT_blend_subtract + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14)) + { + ret = GLEW_EXT_blend_subtract; + continue; + } +#endif +#ifdef GL_EXT_clip_volume_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16)) + { + ret = GLEW_EXT_clip_volume_hint; + continue; + } +#endif +#ifdef GL_EXT_cmyka + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5)) + { + ret = GLEW_EXT_cmyka; + continue; + } +#endif +#ifdef GL_EXT_color_subtable + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14)) + { + ret = GLEW_EXT_color_subtable; + continue; + } +#endif +#ifdef GL_EXT_compiled_vertex_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21)) + { + ret = GLEW_EXT_compiled_vertex_array; + continue; + } +#endif +#ifdef GL_EXT_convolution + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11)) + { + ret = GLEW_EXT_convolution; + continue; + } +#endif +#ifdef GL_EXT_coordinate_frame + if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16)) + { + ret = GLEW_EXT_coordinate_frame; + continue; + } +#endif +#ifdef GL_EXT_copy_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12)) + { + ret = GLEW_EXT_copy_texture; + continue; + } +#endif +#ifdef GL_EXT_cull_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) + { + ret = GLEW_EXT_cull_vertex; + continue; + } +#endif +#ifdef GL_EXT_depth_bounds_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17)) + { + ret = GLEW_EXT_depth_bounds_test; + continue; + } +#endif +#ifdef GL_EXT_direct_state_access + if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19)) + { + ret = GLEW_EXT_direct_state_access; + continue; + } +#endif +#ifdef GL_EXT_draw_buffers2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13)) + { + ret = GLEW_EXT_draw_buffers2; + continue; + } +#endif +#ifdef GL_EXT_draw_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) + { + ret = GLEW_EXT_draw_instanced; + continue; + } +#endif +#ifdef GL_EXT_draw_range_elements + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19)) + { + ret = GLEW_EXT_draw_range_elements; + continue; + } +#endif +#ifdef GL_EXT_fog_coord + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9)) + { + ret = GLEW_EXT_fog_coord; + continue; + } +#endif +#ifdef GL_EXT_fragment_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17)) + { + ret = GLEW_EXT_fragment_lighting; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_blit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) + { + ret = GLEW_EXT_framebuffer_blit; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) + { + ret = GLEW_EXT_framebuffer_multisample; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_multisample_blit_scaled + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35)) + { + ret = GLEW_EXT_framebuffer_multisample_blit_scaled; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) + { + ret = GLEW_EXT_framebuffer_object; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef GL_EXT_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_EXT_geometry_shader4; + continue; + } +#endif +#ifdef GL_EXT_gpu_program_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22)) + { + ret = GLEW_EXT_gpu_program_parameters; + continue; + } +#endif +#ifdef GL_EXT_gpu_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11)) + { + ret = GLEW_EXT_gpu_shader4; + continue; + } +#endif +#ifdef GL_EXT_histogram + if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9)) + { + ret = GLEW_EXT_histogram; + continue; + } +#endif +#ifdef GL_EXT_index_array_formats + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19)) + { + ret = GLEW_EXT_index_array_formats; + continue; + } +#endif +#ifdef GL_EXT_index_func + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10)) + { + ret = GLEW_EXT_index_func; + continue; + } +#endif +#ifdef GL_EXT_index_material + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14)) + { + ret = GLEW_EXT_index_material; + continue; + } +#endif +#ifdef GL_EXT_index_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13)) + { + ret = GLEW_EXT_index_texture; + continue; + } +#endif +#ifdef GL_EXT_light_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13)) + { + ret = GLEW_EXT_light_texture; + continue; + } +#endif +#ifdef GL_EXT_misc_attribute + if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14)) + { + ret = GLEW_EXT_misc_attribute; + continue; + } +#endif +#ifdef GL_EXT_multi_draw_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17)) + { + ret = GLEW_EXT_multi_draw_arrays; + continue; + } +#endif +#ifdef GL_EXT_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_EXT_multisample; + continue; + } +#endif +#ifdef GL_EXT_packed_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) + { + ret = GLEW_EXT_packed_depth_stencil; + continue; + } +#endif +#ifdef GL_EXT_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12)) + { + ret = GLEW_EXT_packed_float; + continue; + } +#endif +#ifdef GL_EXT_packed_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13)) + { + ret = GLEW_EXT_packed_pixels; + continue; + } +#endif +#ifdef GL_EXT_paletted_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16)) + { + ret = GLEW_EXT_paletted_texture; + continue; + } +#endif +#ifdef GL_EXT_pixel_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) + { + ret = GLEW_EXT_pixel_buffer_object; + continue; + } +#endif +#ifdef GL_EXT_pixel_transform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15)) + { + ret = GLEW_EXT_pixel_transform; + continue; + } +#endif +#ifdef GL_EXT_pixel_transform_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27)) + { + ret = GLEW_EXT_pixel_transform_color_table; + continue; + } +#endif +#ifdef GL_EXT_point_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) + { + ret = GLEW_EXT_point_parameters; + continue; + } +#endif +#ifdef GL_EXT_polygon_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14)) + { + ret = GLEW_EXT_polygon_offset; + continue; + } +#endif +#ifdef GL_EXT_provoking_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) + { + ret = GLEW_EXT_provoking_vertex; + continue; + } +#endif +#ifdef GL_EXT_rescale_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14)) + { + ret = GLEW_EXT_rescale_normal; + continue; + } +#endif +#ifdef GL_EXT_scene_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) + { + ret = GLEW_EXT_scene_marker; + continue; + } +#endif +#ifdef GL_EXT_secondary_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15)) + { + ret = GLEW_EXT_secondary_color; + continue; + } +#endif +#ifdef GL_EXT_separate_shader_objects + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) + { + ret = GLEW_EXT_separate_shader_objects; + continue; + } +#endif +#ifdef GL_EXT_separate_specular_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23)) + { + ret = GLEW_EXT_separate_specular_color; + continue; + } +#endif +#ifdef GL_EXT_shader_image_load_store + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23)) + { + ret = GLEW_EXT_shader_image_load_store; + continue; + } +#endif +#ifdef GL_EXT_shadow_funcs + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12)) + { + ret = GLEW_EXT_shadow_funcs; + continue; + } +#endif +#ifdef GL_EXT_shared_texture_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22)) + { + ret = GLEW_EXT_shared_texture_palette; + continue; + } +#endif +#ifdef GL_EXT_stencil_clear_tag + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17)) + { + ret = GLEW_EXT_stencil_clear_tag; + continue; + } +#endif +#ifdef GL_EXT_stencil_two_side + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16)) + { + ret = GLEW_EXT_stencil_two_side; + continue; + } +#endif +#ifdef GL_EXT_stencil_wrap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12)) + { + ret = GLEW_EXT_stencil_wrap; + continue; + } +#endif +#ifdef GL_EXT_subtexture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10)) + { + ret = GLEW_EXT_subtexture; + continue; + } +#endif +#ifdef GL_EXT_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7)) + { + ret = GLEW_EXT_texture; + continue; + } +#endif +#ifdef GL_EXT_texture3D + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9)) + { + ret = GLEW_EXT_texture3D; + continue; + } +#endif +#ifdef GL_EXT_texture_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13)) + { + ret = GLEW_EXT_texture_array; + continue; + } +#endif +#ifdef GL_EXT_texture_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) + { + ret = GLEW_EXT_texture_buffer_object; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_dxt1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24)) + { + ret = GLEW_EXT_texture_compression_dxt1; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_latc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24)) + { + ret = GLEW_EXT_texture_compression_latc; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_rgtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) + { + ret = GLEW_EXT_texture_compression_rgtc; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_s3tc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24)) + { + ret = GLEW_EXT_texture_compression_s3tc; + continue; + } +#endif +#ifdef GL_EXT_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) + { + ret = GLEW_EXT_texture_cube_map; + continue; + } +#endif +#ifdef GL_EXT_texture_edge_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) + { + ret = GLEW_EXT_texture_edge_clamp; + continue; + } +#endif +#ifdef GL_EXT_texture_env + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11)) + { + ret = GLEW_EXT_texture_env; + continue; + } +#endif +#ifdef GL_EXT_texture_env_add + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) + { + ret = GLEW_EXT_texture_env_add; + continue; + } +#endif +#ifdef GL_EXT_texture_env_combine + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) + { + ret = GLEW_EXT_texture_env_combine; + continue; + } +#endif +#ifdef GL_EXT_texture_env_dot3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) + { + ret = GLEW_EXT_texture_env_dot3; + continue; + } +#endif +#ifdef GL_EXT_texture_filter_anisotropic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26)) + { + ret = GLEW_EXT_texture_filter_anisotropic; + continue; + } +#endif +#ifdef GL_EXT_texture_integer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15)) + { + ret = GLEW_EXT_texture_integer; + continue; + } +#endif +#ifdef GL_EXT_texture_lod_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) + { + ret = GLEW_EXT_texture_lod_bias; + continue; + } +#endif +#ifdef GL_EXT_texture_mirror_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20)) + { + ret = GLEW_EXT_texture_mirror_clamp; + continue; + } +#endif +#ifdef GL_EXT_texture_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14)) + { + ret = GLEW_EXT_texture_object; + continue; + } +#endif +#ifdef GL_EXT_texture_perturb_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22)) + { + ret = GLEW_EXT_texture_perturb_normal; + continue; + } +#endif +#ifdef GL_EXT_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_EXT_texture_rectangle; + continue; + } +#endif +#ifdef GL_EXT_texture_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12)) + { + ret = GLEW_EXT_texture_sRGB; + continue; + } +#endif +#ifdef GL_EXT_texture_sRGB_decode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19)) + { + ret = GLEW_EXT_texture_sRGB_decode; + continue; + } +#endif +#ifdef GL_EXT_texture_shared_exponent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23)) + { + ret = GLEW_EXT_texture_shared_exponent; + continue; + } +#endif +#ifdef GL_EXT_texture_snorm + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13)) + { + ret = GLEW_EXT_texture_snorm; + continue; + } +#endif +#ifdef GL_EXT_texture_swizzle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) + { + ret = GLEW_EXT_texture_swizzle; + continue; + } +#endif +#ifdef GL_EXT_timer_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) + { + ret = GLEW_EXT_timer_query; + continue; + } +#endif +#ifdef GL_EXT_transform_feedback + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) + { + ret = GLEW_EXT_transform_feedback; + continue; + } +#endif +#ifdef GL_EXT_vertex_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12)) + { + ret = GLEW_EXT_vertex_array; + continue; + } +#endif +#ifdef GL_EXT_vertex_array_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17)) + { + ret = GLEW_EXT_vertex_array_bgra; + continue; + } +#endif +#ifdef GL_EXT_vertex_attrib_64bit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19)) + { + ret = GLEW_EXT_vertex_attrib_64bit; + continue; + } +#endif +#ifdef GL_EXT_vertex_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) + { + ret = GLEW_EXT_vertex_shader; + continue; + } +#endif +#ifdef GL_EXT_vertex_weighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16)) + { + ret = GLEW_EXT_vertex_weighting; + continue; + } +#endif +#ifdef GL_EXT_x11_sync_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15)) + { + ret = GLEW_EXT_x11_sync_object; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8)) + { +#ifdef GL_GREMEDY_frame_terminator + if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16)) + { + ret = GLEW_GREMEDY_frame_terminator; + continue; + } +#endif +#ifdef GL_GREMEDY_string_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13)) + { + ret = GLEW_GREMEDY_string_marker; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3)) + { +#ifdef GL_HP_convolution_border_modes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) + { + ret = GLEW_HP_convolution_border_modes; + continue; + } +#endif +#ifdef GL_HP_image_transform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15)) + { + ret = GLEW_HP_image_transform; + continue; + } +#endif +#ifdef GL_HP_occlusion_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14)) + { + ret = GLEW_HP_occlusion_test; + continue; + } +#endif +#ifdef GL_HP_texture_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16)) + { + ret = GLEW_HP_texture_lighting; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4)) + { +#ifdef GL_IBM_cull_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) + { + ret = GLEW_IBM_cull_vertex; + continue; + } +#endif +#ifdef GL_IBM_multimode_draw_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21)) + { + ret = GLEW_IBM_multimode_draw_arrays; + continue; + } +#endif +#ifdef GL_IBM_rasterpos_clip + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14)) + { + ret = GLEW_IBM_rasterpos_clip; + continue; + } +#endif +#ifdef GL_IBM_static_data + if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11)) + { + ret = GLEW_IBM_static_data; + continue; + } +#endif +#ifdef GL_IBM_texture_mirrored_repeat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) + { + ret = GLEW_IBM_texture_mirrored_repeat; + continue; + } +#endif +#ifdef GL_IBM_vertex_array_lists + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18)) + { + ret = GLEW_IBM_vertex_array_lists; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5)) + { +#ifdef GL_INGR_color_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11)) + { + ret = GLEW_INGR_color_clamp; + continue; + } +#endif +#ifdef GL_INGR_interlace_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14)) + { + ret = GLEW_INGR_interlace_read; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) + { +#ifdef GL_INTEL_parallel_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15)) + { + ret = GLEW_INTEL_parallel_arrays; + continue; + } +#endif +#ifdef GL_INTEL_texture_scissor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15)) + { + ret = GLEW_INTEL_texture_scissor; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4)) + { +#ifdef GL_KTX_buffer_region + if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) + { + ret = GLEW_KTX_buffer_region; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6)) + { +#ifdef GL_MESAX_texture_stack + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13)) + { + ret = GLEW_MESAX_texture_stack; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) + { +#ifdef GL_MESA_pack_invert + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11)) + { + ret = GLEW_MESA_pack_invert; + continue; + } +#endif +#ifdef GL_MESA_resize_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14)) + { + ret = GLEW_MESA_resize_buffers; + continue; + } +#endif +#ifdef GL_MESA_window_pos + if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) + { + ret = GLEW_MESA_window_pos; + continue; + } +#endif +#ifdef GL_MESA_ycbcr_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13)) + { + ret = GLEW_MESA_ycbcr_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4)) + { +#ifdef GL_NVX_gpu_memory_info + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15)) + { + ret = GLEW_NVX_gpu_memory_info; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef GL_NV_blend_square + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12)) + { + ret = GLEW_NV_blend_square; + continue; + } +#endif +#ifdef GL_NV_conditional_render + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18)) + { + ret = GLEW_NV_conditional_render; + continue; + } +#endif +#ifdef GL_NV_copy_depth_to_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19)) + { + ret = GLEW_NV_copy_depth_to_color; + continue; + } +#endif +#ifdef GL_NV_copy_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) + { + ret = GLEW_NV_copy_image; + continue; + } +#endif +#ifdef GL_NV_depth_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) + { + ret = GLEW_NV_depth_buffer_float; + continue; + } +#endif +#ifdef GL_NV_depth_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11)) + { + ret = GLEW_NV_depth_clamp; + continue; + } +#endif +#ifdef GL_NV_depth_range_unclamped + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21)) + { + ret = GLEW_NV_depth_range_unclamped; + continue; + } +#endif +#ifdef GL_NV_evaluators + if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10)) + { + ret = GLEW_NV_evaluators; + continue; + } +#endif +#ifdef GL_NV_explicit_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20)) + { + ret = GLEW_NV_explicit_multisample; + continue; + } +#endif +#ifdef GL_NV_fence + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) + { + ret = GLEW_NV_fence; + continue; + } +#endif +#ifdef GL_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = GLEW_NV_float_buffer; + continue; + } +#endif +#ifdef GL_NV_fog_distance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12)) + { + ret = GLEW_NV_fog_distance; + continue; + } +#endif +#ifdef GL_NV_fragment_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) + { + ret = GLEW_NV_fragment_program; + continue; + } +#endif +#ifdef GL_NV_fragment_program2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17)) + { + ret = GLEW_NV_fragment_program2; + continue; + } +#endif +#ifdef GL_NV_fragment_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17)) + { + ret = GLEW_NV_fragment_program4; + continue; + } +#endif +#ifdef GL_NV_fragment_program_option + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23)) + { + ret = GLEW_NV_fragment_program_option; + continue; + } +#endif +#ifdef GL_NV_framebuffer_multisample_coverage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32)) + { + ret = GLEW_NV_framebuffer_multisample_coverage; + continue; + } +#endif +#ifdef GL_NV_geometry_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17)) + { + ret = GLEW_NV_geometry_program4; + continue; + } +#endif +#ifdef GL_NV_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_NV_geometry_shader4; + continue; + } +#endif +#ifdef GL_NV_gpu_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12)) + { + ret = GLEW_NV_gpu_program4; + continue; + } +#endif +#ifdef GL_NV_gpu_program5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12)) + { + ret = GLEW_NV_gpu_program5; + continue; + } +#endif +#ifdef GL_NV_gpu_program_fp64 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16)) + { + ret = GLEW_NV_gpu_program_fp64; + continue; + } +#endif +#ifdef GL_NV_gpu_shader5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) + { + ret = GLEW_NV_gpu_shader5; + continue; + } +#endif +#ifdef GL_NV_half_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10)) + { + ret = GLEW_NV_half_float; + continue; + } +#endif +#ifdef GL_NV_light_max_exponent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18)) + { + ret = GLEW_NV_light_max_exponent; + continue; + } +#endif +#ifdef GL_NV_multisample_coverage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) + { + ret = GLEW_NV_multisample_coverage; + continue; + } +#endif +#ifdef GL_NV_multisample_filter_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23)) + { + ret = GLEW_NV_multisample_filter_hint; + continue; + } +#endif +#ifdef GL_NV_occlusion_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) + { + ret = GLEW_NV_occlusion_query; + continue; + } +#endif +#ifdef GL_NV_packed_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) + { + ret = GLEW_NV_packed_depth_stencil; + continue; + } +#endif +#ifdef GL_NV_parameter_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23)) + { + ret = GLEW_NV_parameter_buffer_object; + continue; + } +#endif +#ifdef GL_NV_parameter_buffer_object2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24)) + { + ret = GLEW_NV_parameter_buffer_object2; + continue; + } +#endif +#ifdef GL_NV_path_rendering + if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14)) + { + ret = GLEW_NV_path_rendering; + continue; + } +#endif +#ifdef GL_NV_pixel_data_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16)) + { + ret = GLEW_NV_pixel_data_range; + continue; + } +#endif +#ifdef GL_NV_point_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) + { + ret = GLEW_NV_point_sprite; + continue; + } +#endif +#ifdef GL_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = GLEW_NV_present_video; + continue; + } +#endif +#ifdef GL_NV_primitive_restart + if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17)) + { + ret = GLEW_NV_primitive_restart; + continue; + } +#endif +#ifdef GL_NV_register_combiners + if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18)) + { + ret = GLEW_NV_register_combiners; + continue; + } +#endif +#ifdef GL_NV_register_combiners2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19)) + { + ret = GLEW_NV_register_combiners2; + continue; + } +#endif +#ifdef GL_NV_shader_buffer_load + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18)) + { + ret = GLEW_NV_shader_buffer_load; + continue; + } +#endif +#ifdef GL_NV_tessellation_program5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21)) + { + ret = GLEW_NV_tessellation_program5; + continue; + } +#endif +#ifdef GL_NV_texgen_emboss + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13)) + { + ret = GLEW_NV_texgen_emboss; + continue; + } +#endif +#ifdef GL_NV_texgen_reflection + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17)) + { + ret = GLEW_NV_texgen_reflection; + continue; + } +#endif +#ifdef GL_NV_texture_barrier + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15)) + { + ret = GLEW_NV_texture_barrier; + continue; + } +#endif +#ifdef GL_NV_texture_compression_vtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23)) + { + ret = GLEW_NV_texture_compression_vtc; + continue; + } +#endif +#ifdef GL_NV_texture_env_combine4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20)) + { + ret = GLEW_NV_texture_env_combine4; + continue; + } +#endif +#ifdef GL_NV_texture_expand_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21)) + { + ret = GLEW_NV_texture_expand_normal; + continue; + } +#endif +#ifdef GL_NV_texture_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19)) + { + ret = GLEW_NV_texture_multisample; + continue; + } +#endif +#ifdef GL_NV_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_NV_texture_rectangle; + continue; + } +#endif +#ifdef GL_NV_texture_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14)) + { + ret = GLEW_NV_texture_shader; + continue; + } +#endif +#ifdef GL_NV_texture_shader2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15)) + { + ret = GLEW_NV_texture_shader2; + continue; + } +#endif +#ifdef GL_NV_texture_shader3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15)) + { + ret = GLEW_NV_texture_shader3; + continue; + } +#endif +#ifdef GL_NV_transform_feedback + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) + { + ret = GLEW_NV_transform_feedback; + continue; + } +#endif +#ifdef GL_NV_transform_feedback2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19)) + { + ret = GLEW_NV_transform_feedback2; + continue; + } +#endif +#ifdef GL_NV_vdpau_interop + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13)) + { + ret = GLEW_NV_vdpau_interop; + continue; + } +#endif +#ifdef GL_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef GL_NV_vertex_array_range2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19)) + { + ret = GLEW_NV_vertex_array_range2; + continue; + } +#endif +#ifdef GL_NV_vertex_attrib_integer_64bit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27)) + { + ret = GLEW_NV_vertex_attrib_integer_64bit; + continue; + } +#endif +#ifdef GL_NV_vertex_buffer_unified_memory + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28)) + { + ret = GLEW_NV_vertex_buffer_unified_memory; + continue; + } +#endif +#ifdef GL_NV_vertex_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) + { + ret = GLEW_NV_vertex_program; + continue; + } +#endif +#ifdef GL_NV_vertex_program1_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17)) + { + ret = GLEW_NV_vertex_program1_1; + continue; + } +#endif +#ifdef GL_NV_vertex_program2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15)) + { + ret = GLEW_NV_vertex_program2; + continue; + } +#endif +#ifdef GL_NV_vertex_program2_option + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22)) + { + ret = GLEW_NV_vertex_program2_option; + continue; + } +#endif +#ifdef GL_NV_vertex_program3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15)) + { + ret = GLEW_NV_vertex_program3; + continue; + } +#endif +#ifdef GL_NV_vertex_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15)) + { + ret = GLEW_NV_vertex_program4; + continue; + } +#endif +#ifdef GL_NV_video_capture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) + { + ret = GLEW_NV_video_capture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4)) + { +#ifdef GL_OES_byte_coordinates + if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16)) + { + ret = GLEW_OES_byte_coordinates; + continue; + } +#endif +#ifdef GL_OES_compressed_paletted_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27)) + { + ret = GLEW_OES_compressed_paletted_texture; + continue; + } +#endif +#ifdef GL_OES_read_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) + { + ret = GLEW_OES_read_format; + continue; + } +#endif +#ifdef GL_OES_single_precision + if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16)) + { + ret = GLEW_OES_single_precision; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef GL_OML_interlace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) + { + ret = GLEW_OML_interlace; + continue; + } +#endif +#ifdef GL_OML_resample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) + { + ret = GLEW_OML_resample; + continue; + } +#endif +#ifdef GL_OML_subsample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9)) + { + ret = GLEW_OML_subsample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4)) + { +#ifdef GL_PGI_misc_hints + if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10)) + { + ret = GLEW_PGI_misc_hints; + continue; + } +#endif +#ifdef GL_PGI_vertex_hints + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12)) + { + ret = GLEW_PGI_vertex_hints; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5)) + { +#ifdef GL_REND_screen_coordinates + if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18)) + { + ret = GLEW_REND_screen_coordinates; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3)) + { +#ifdef GL_S3_s3tc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4)) + { + ret = GLEW_S3_s3tc; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) + { +#ifdef GL_SGIS_color_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) + { + ret = GLEW_SGIS_color_range; + continue; + } +#endif +#ifdef GL_SGIS_detail_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14)) + { + ret = GLEW_SGIS_detail_texture; + continue; + } +#endif +#ifdef GL_SGIS_fog_function + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12)) + { + ret = GLEW_SGIS_fog_function; + continue; + } +#endif +#ifdef GL_SGIS_generate_mipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15)) + { + ret = GLEW_SGIS_generate_mipmap; + continue; + } +#endif +#ifdef GL_SGIS_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_SGIS_multisample; + continue; + } +#endif +#ifdef GL_SGIS_pixel_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) + { + ret = GLEW_SGIS_pixel_texture; + continue; + } +#endif +#ifdef GL_SGIS_point_line_texgen + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17)) + { + ret = GLEW_SGIS_point_line_texgen; + continue; + } +#endif +#ifdef GL_SGIS_sharpen_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15)) + { + ret = GLEW_SGIS_sharpen_texture; + continue; + } +#endif +#ifdef GL_SGIS_texture4D + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9)) + { + ret = GLEW_SGIS_texture4D; + continue; + } +#endif +#ifdef GL_SGIS_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_SGIS_texture_border_clamp; + continue; + } +#endif +#ifdef GL_SGIS_texture_edge_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) + { + ret = GLEW_SGIS_texture_edge_clamp; + continue; + } +#endif +#ifdef GL_SGIS_texture_filter4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15)) + { + ret = GLEW_SGIS_texture_filter4; + continue; + } +#endif +#ifdef GL_SGIS_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11)) + { + ret = GLEW_SGIS_texture_lod; + continue; + } +#endif +#ifdef GL_SGIS_texture_select + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14)) + { + ret = GLEW_SGIS_texture_select; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) + { +#ifdef GL_SGIX_async + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5)) + { + ret = GLEW_SGIX_async; + continue; + } +#endif +#ifdef GL_SGIX_async_histogram + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15)) + { + ret = GLEW_SGIX_async_histogram; + continue; + } +#endif +#ifdef GL_SGIX_async_pixel + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11)) + { + ret = GLEW_SGIX_async_pixel; + continue; + } +#endif +#ifdef GL_SGIX_blend_alpha_minmax + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18)) + { + ret = GLEW_SGIX_blend_alpha_minmax; + continue; + } +#endif +#ifdef GL_SGIX_clipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7)) + { + ret = GLEW_SGIX_clipmap; + continue; + } +#endif +#ifdef GL_SGIX_convolution_accuracy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20)) + { + ret = GLEW_SGIX_convolution_accuracy; + continue; + } +#endif +#ifdef GL_SGIX_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) + { + ret = GLEW_SGIX_depth_texture; + continue; + } +#endif +#ifdef GL_SGIX_flush_raster + if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12)) + { + ret = GLEW_SGIX_flush_raster; + continue; + } +#endif +#ifdef GL_SGIX_fog_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10)) + { + ret = GLEW_SGIX_fog_offset; + continue; + } +#endif +#ifdef GL_SGIX_fog_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11)) + { + ret = GLEW_SGIX_fog_texture; + continue; + } +#endif +#ifdef GL_SGIX_fragment_specular_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26)) + { + ret = GLEW_SGIX_fragment_specular_lighting; + continue; + } +#endif +#ifdef GL_SGIX_framezoom + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9)) + { + ret = GLEW_SGIX_framezoom; + continue; + } +#endif +#ifdef GL_SGIX_interlace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) + { + ret = GLEW_SGIX_interlace; + continue; + } +#endif +#ifdef GL_SGIX_ir_instrument1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14)) + { + ret = GLEW_SGIX_ir_instrument1; + continue; + } +#endif +#ifdef GL_SGIX_list_priority + if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13)) + { + ret = GLEW_SGIX_list_priority; + continue; + } +#endif +#ifdef GL_SGIX_pixel_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) + { + ret = GLEW_SGIX_pixel_texture; + continue; + } +#endif +#ifdef GL_SGIX_pixel_texture_bits + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18)) + { + ret = GLEW_SGIX_pixel_texture_bits; + continue; + } +#endif +#ifdef GL_SGIX_reference_plane + if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15)) + { + ret = GLEW_SGIX_reference_plane; + continue; + } +#endif +#ifdef GL_SGIX_resample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) + { + ret = GLEW_SGIX_resample; + continue; + } +#endif +#ifdef GL_SGIX_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) + { + ret = GLEW_SGIX_shadow; + continue; + } +#endif +#ifdef GL_SGIX_shadow_ambient + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) + { + ret = GLEW_SGIX_shadow_ambient; + continue; + } +#endif +#ifdef GL_SGIX_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6)) + { + ret = GLEW_SGIX_sprite; + continue; + } +#endif +#ifdef GL_SGIX_tag_sample_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17)) + { + ret = GLEW_SGIX_tag_sample_buffer; + continue; + } +#endif +#ifdef GL_SGIX_texture_add_env + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15)) + { + ret = GLEW_SGIX_texture_add_env; + continue; + } +#endif +#ifdef GL_SGIX_texture_coordinate_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24)) + { + ret = GLEW_SGIX_texture_coordinate_clamp; + continue; + } +#endif +#ifdef GL_SGIX_texture_lod_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) + { + ret = GLEW_SGIX_texture_lod_bias; + continue; + } +#endif +#ifdef GL_SGIX_texture_multi_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20)) + { + ret = GLEW_SGIX_texture_multi_buffer; + continue; + } +#endif +#ifdef GL_SGIX_texture_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) + { + ret = GLEW_SGIX_texture_range; + continue; + } +#endif +#ifdef GL_SGIX_texture_scale_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18)) + { + ret = GLEW_SGIX_texture_scale_bias; + continue; + } +#endif +#ifdef GL_SGIX_vertex_preclip + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14)) + { + ret = GLEW_SGIX_vertex_preclip; + continue; + } +#endif +#ifdef GL_SGIX_vertex_preclip_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19)) + { + ret = GLEW_SGIX_vertex_preclip_hint; + continue; + } +#endif +#ifdef GL_SGIX_ycrcb + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5)) + { + ret = GLEW_SGIX_ycrcb; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) + { +#ifdef GL_SGI_color_matrix + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12)) + { + ret = GLEW_SGI_color_matrix; + continue; + } +#endif +#ifdef GL_SGI_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11)) + { + ret = GLEW_SGI_color_table; + continue; + } +#endif +#ifdef GL_SGI_texture_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19)) + { + ret = GLEW_SGI_texture_color_table; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5)) + { +#ifdef GL_SUNX_constant_data + if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13)) + { + ret = GLEW_SUNX_constant_data; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) + { +#ifdef GL_SUN_convolution_border_modes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) + { + ret = GLEW_SUN_convolution_border_modes; + continue; + } +#endif +#ifdef GL_SUN_global_alpha + if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12)) + { + ret = GLEW_SUN_global_alpha; + continue; + } +#endif +#ifdef GL_SUN_mesh_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10)) + { + ret = GLEW_SUN_mesh_array; + continue; + } +#endif +#ifdef GL_SUN_read_video_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17)) + { + ret = GLEW_SUN_read_video_pixels; + continue; + } +#endif +#ifdef GL_SUN_slice_accum + if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11)) + { + ret = GLEW_SUN_slice_accum; + continue; + } +#endif +#ifdef GL_SUN_triangle_list + if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13)) + { + ret = GLEW_SUN_triangle_list; + continue; + } +#endif +#ifdef GL_SUN_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6)) + { + ret = GLEW_SUN_vertex; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4)) + { +#ifdef GL_WIN_phong_shading + if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13)) + { + ret = GLEW_WIN_phong_shading; + continue; + } +#endif +#ifdef GL_WIN_specular_fog + if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12)) + { + ret = GLEW_WIN_specular_fog; + continue; + } +#endif +#ifdef GL_WIN_swap_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9)) + { + ret = GLEW_WIN_swap_hint; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#if defined(_WIN32) + +#if defined(GLEW_MX) +GLboolean wglewContextIsSupported (const WGLEWContext* ctx, const char* name) +#else +GLboolean wglewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef WGL_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_3DFX_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4)) + { +#ifdef WGL_3DL_stereo_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14)) + { + ret = WGLEW_3DL_stereo_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) + { +#ifdef WGL_AMD_gpu_association + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15)) + { + ret = WGLEW_AMD_gpu_association; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef WGL_ARB_buffer_region + if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) + { + ret = WGLEW_ARB_buffer_region; + continue; + } +#endif +#ifdef WGL_ARB_create_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) + { + ret = WGLEW_ARB_create_context; + continue; + } +#endif +#ifdef WGL_ARB_create_context_profile + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) + { + ret = WGLEW_ARB_create_context_profile; + continue; + } +#endif +#ifdef WGL_ARB_create_context_robustness + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) + { + ret = WGLEW_ARB_create_context_robustness; + continue; + } +#endif +#ifdef WGL_ARB_extensions_string + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) + { + ret = WGLEW_ARB_extensions_string; + continue; + } +#endif +#ifdef WGL_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = WGLEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef WGL_ARB_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = WGLEW_ARB_make_current_read; + continue; + } +#endif +#ifdef WGL_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_ARB_multisample; + continue; + } +#endif +#ifdef WGL_ARB_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = WGLEW_ARB_pbuffer; + continue; + } +#endif +#ifdef WGL_ARB_pixel_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) + { + ret = WGLEW_ARB_pixel_format; + continue; + } +#endif +#ifdef WGL_ARB_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = WGLEW_ARB_pixel_format_float; + continue; + } +#endif +#ifdef WGL_ARB_render_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) + { + ret = WGLEW_ARB_render_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef WGL_ATI_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = WGLEW_ATI_pixel_format_float; + continue; + } +#endif +#ifdef WGL_ATI_render_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) + { + ret = WGLEW_ATI_render_texture_rectangle; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef WGL_EXT_create_context_es2_profile + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26)) + { + ret = WGLEW_EXT_create_context_es2_profile; + continue; + } +#endif +#ifdef WGL_EXT_depth_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11)) + { + ret = WGLEW_EXT_depth_float; + continue; + } +#endif +#ifdef WGL_EXT_display_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19)) + { + ret = WGLEW_EXT_display_color_table; + continue; + } +#endif +#ifdef WGL_EXT_extensions_string + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) + { + ret = WGLEW_EXT_extensions_string; + continue; + } +#endif +#ifdef WGL_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = WGLEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef WGL_EXT_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = WGLEW_EXT_make_current_read; + continue; + } +#endif +#ifdef WGL_EXT_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_EXT_multisample; + continue; + } +#endif +#ifdef WGL_EXT_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = WGLEW_EXT_pbuffer; + continue; + } +#endif +#ifdef WGL_EXT_pixel_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) + { + ret = WGLEW_EXT_pixel_format; + continue; + } +#endif +#ifdef WGL_EXT_pixel_format_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25)) + { + ret = WGLEW_EXT_pixel_format_packed_float; + continue; + } +#endif +#ifdef WGL_EXT_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = WGLEW_EXT_swap_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4)) + { +#ifdef WGL_I3D_digital_video_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21)) + { + ret = WGLEW_I3D_digital_video_control; + continue; + } +#endif +#ifdef WGL_I3D_gamma + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5)) + { + ret = WGLEW_I3D_gamma; + continue; + } +#endif +#ifdef WGL_I3D_genlock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7)) + { + ret = WGLEW_I3D_genlock; + continue; + } +#endif +#ifdef WGL_I3D_image_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12)) + { + ret = WGLEW_I3D_image_buffer; + continue; + } +#endif +#ifdef WGL_I3D_swap_frame_lock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15)) + { + ret = WGLEW_I3D_swap_frame_lock; + continue; + } +#endif +#ifdef WGL_I3D_swap_frame_usage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16)) + { + ret = WGLEW_I3D_swap_frame_usage; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef WGL_NV_DX_interop + if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10)) + { + ret = WGLEW_NV_DX_interop; + continue; + } +#endif +#ifdef WGL_NV_copy_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) + { + ret = WGLEW_NV_copy_image; + continue; + } +#endif +#ifdef WGL_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = WGLEW_NV_float_buffer; + continue; + } +#endif +#ifdef WGL_NV_gpu_affinity + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12)) + { + ret = WGLEW_NV_gpu_affinity; + continue; + } +#endif +#ifdef WGL_NV_multisample_coverage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) + { + ret = WGLEW_NV_multisample_coverage; + continue; + } +#endif +#ifdef WGL_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = WGLEW_NV_present_video; + continue; + } +#endif +#ifdef WGL_NV_render_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20)) + { + ret = WGLEW_NV_render_depth_texture; + continue; + } +#endif +#ifdef WGL_NV_render_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) + { + ret = WGLEW_NV_render_texture_rectangle; + continue; + } +#endif +#ifdef WGL_NV_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = WGLEW_NV_swap_group; + continue; + } +#endif +#ifdef WGL_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = WGLEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef WGL_NV_video_capture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) + { + ret = WGLEW_NV_video_capture; + continue; + } +#endif +#ifdef WGL_NV_video_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12)) + { + ret = WGLEW_NV_video_output; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef WGL_OML_sync_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) + { + ret = WGLEW_OML_sync_control; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) + +#if defined(GLEW_MX) +GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name) +#else +GLboolean glxewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) + { +#ifdef GLX_VERSION_1_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) + { + ret = GLXEW_VERSION_1_2; + continue; + } +#endif +#ifdef GLX_VERSION_1_3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) + { + ret = GLXEW_VERSION_1_3; + continue; + } +#endif +#ifdef GLX_VERSION_1_4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) + { + ret = GLXEW_VERSION_1_4; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef GLX_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_3DFX_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) + { +#ifdef GLX_AMD_gpu_association + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15)) + { + ret = GLXEW_AMD_gpu_association; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef GLX_ARB_create_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) + { + ret = GLXEW_ARB_create_context; + continue; + } +#endif +#ifdef GLX_ARB_create_context_profile + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) + { + ret = GLXEW_ARB_create_context_profile; + continue; + } +#endif +#ifdef GLX_ARB_create_context_robustness + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) + { + ret = GLXEW_ARB_create_context_robustness; + continue; + } +#endif +#ifdef GLX_ARB_fbconfig_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14)) + { + ret = GLXEW_ARB_fbconfig_float; + continue; + } +#endif +#ifdef GLX_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLXEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef GLX_ARB_get_proc_address + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16)) + { + ret = GLXEW_ARB_get_proc_address; + continue; + } +#endif +#ifdef GLX_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_ARB_multisample; + continue; + } +#endif +#ifdef GLX_ARB_vertex_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20)) + { + ret = GLXEW_ARB_vertex_buffer_object; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef GLX_ATI_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = GLXEW_ATI_pixel_format_float; + continue; + } +#endif +#ifdef GLX_ATI_render_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) + { + ret = GLXEW_ATI_render_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef GLX_EXT_create_context_es2_profile + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26)) + { + ret = GLXEW_EXT_create_context_es2_profile; + continue; + } +#endif +#ifdef GLX_EXT_fbconfig_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21)) + { + ret = GLXEW_EXT_fbconfig_packed_float; + continue; + } +#endif +#ifdef GLX_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLXEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef GLX_EXT_import_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14)) + { + ret = GLXEW_EXT_import_context; + continue; + } +#endif +#ifdef GLX_EXT_scene_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) + { + ret = GLXEW_EXT_scene_marker; + continue; + } +#endif +#ifdef GLX_EXT_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = GLXEW_EXT_swap_control; + continue; + } +#endif +#ifdef GLX_EXT_texture_from_pixmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19)) + { + ret = GLXEW_EXT_texture_from_pixmap; + continue; + } +#endif +#ifdef GLX_EXT_visual_info + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11)) + { + ret = GLXEW_EXT_visual_info; + continue; + } +#endif +#ifdef GLX_EXT_visual_rating + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13)) + { + ret = GLXEW_EXT_visual_rating; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) + { +#ifdef GLX_INTEL_swap_event + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10)) + { + ret = GLXEW_INTEL_swap_event; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) + { +#ifdef GLX_MESA_agp_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10)) + { + ret = GLXEW_MESA_agp_offset; + continue; + } +#endif +#ifdef GLX_MESA_copy_sub_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15)) + { + ret = GLXEW_MESA_copy_sub_buffer; + continue; + } +#endif +#ifdef GLX_MESA_pixmap_colormap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15)) + { + ret = GLXEW_MESA_pixmap_colormap; + continue; + } +#endif +#ifdef GLX_MESA_release_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15)) + { + ret = GLXEW_MESA_release_buffers; + continue; + } +#endif +#ifdef GLX_MESA_set_3dfx_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13)) + { + ret = GLXEW_MESA_set_3dfx_mode; + continue; + } +#endif +#ifdef GLX_MESA_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = GLXEW_MESA_swap_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef GLX_NV_copy_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) + { + ret = GLXEW_NV_copy_image; + continue; + } +#endif +#ifdef GLX_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = GLXEW_NV_float_buffer; + continue; + } +#endif +#ifdef GLX_NV_multisample_coverage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) + { + ret = GLXEW_NV_multisample_coverage; + continue; + } +#endif +#ifdef GLX_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = GLXEW_NV_present_video; + continue; + } +#endif +#ifdef GLX_NV_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = GLXEW_NV_swap_group; + continue; + } +#endif +#ifdef GLX_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLXEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef GLX_NV_video_capture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) + { + ret = GLXEW_NV_video_capture; + continue; + } +#endif +#ifdef GLX_NV_video_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12)) + { + ret = GLXEW_NV_video_output; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef GLX_OML_swap_method + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11)) + { + ret = GLXEW_OML_swap_method; + continue; + } +#endif +#ifdef GLX_OML_sync_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) + { + ret = GLXEW_OML_sync_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) + { +#ifdef GLX_SGIS_blended_overlay + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15)) + { + ret = GLXEW_SGIS_blended_overlay; + continue; + } +#endif +#ifdef GLX_SGIS_color_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) + { + ret = GLXEW_SGIS_color_range; + continue; + } +#endif +#ifdef GLX_SGIS_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_SGIS_multisample; + continue; + } +#endif +#ifdef GLX_SGIS_shared_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18)) + { + ret = GLXEW_SGIS_shared_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) + { +#ifdef GLX_SGIX_fbconfig + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8)) + { + ret = GLXEW_SGIX_fbconfig; + continue; + } +#endif +#ifdef GLX_SGIX_hyperpipe + if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9)) + { + ret = GLXEW_SGIX_hyperpipe; + continue; + } +#endif +#ifdef GLX_SGIX_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = GLXEW_SGIX_pbuffer; + continue; + } +#endif +#ifdef GLX_SGIX_swap_barrier + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12)) + { + ret = GLXEW_SGIX_swap_barrier; + continue; + } +#endif +#ifdef GLX_SGIX_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = GLXEW_SGIX_swap_group; + continue; + } +#endif +#ifdef GLX_SGIX_video_resize + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) + { + ret = GLXEW_SGIX_video_resize; + continue; + } +#endif +#ifdef GLX_SGIX_visual_select_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19)) + { + ret = GLXEW_SGIX_visual_select_group; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) + { +#ifdef GLX_SGI_cushion + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7)) + { + ret = GLXEW_SGI_cushion; + continue; + } +#endif +#ifdef GLX_SGI_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = GLXEW_SGI_make_current_read; + continue; + } +#endif +#ifdef GLX_SGI_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = GLXEW_SGI_swap_control; + continue; + } +#endif +#ifdef GLX_SGI_video_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10)) + { + ret = GLXEW_SGI_video_sync; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) + { +#ifdef GLX_SUN_get_transparent_index + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21)) + { + ret = GLXEW_SUN_get_transparent_index; + continue; + } +#endif +#ifdef GLX_SUN_video_resize + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) + { + ret = GLXEW_SUN_video_resize; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#endif /* _WIN32 */ diff --git a/lib/glew/glew.h b/lib/glew/glew.h new file mode 100644 index 0000000..0cd6ae3 --- /dev/null +++ b/lib/glew/glew.h @@ -0,0 +1,16126 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* + * Mesa 3-D graphics library + * Version: 7.0 + * + * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* +** Copyright (c) 2007 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __glew_h__ +#define __glew_h__ +#define __GLEW_H__ + +#if defined(__gl_h_) || defined(__GL_H__) || defined(__X_GL_H) +#error gl.h included before glew.h +#endif +#if defined(__glext_h_) || defined(__GLEXT_H_) +#error glext.h included before glew.h +#endif +#if defined(__gl_ATI_h_) +#error glATI.h included before glew.h +#endif + +#define __gl_h_ +#define __GL_H__ +#define __X_GL_H +#define __glext_h_ +#define __GLEXT_H_ +#define __gl_ATI_h_ + +#if defined(_WIN32) + +/* + * GLEW does not include to avoid name space pollution. + * GL needs GLAPI and GLAPIENTRY, GLU needs APIENTRY, CALLBACK, and wchar_t + * defined properly. + */ +/* */ +#ifndef APIENTRY +#define GLEW_APIENTRY_DEFINED +# if defined(__MINGW32__) || defined(__CYGWIN__) +# define APIENTRY __stdcall +# elif (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +#endif +#ifndef GLAPI +# if defined(__MINGW32__) || defined(__CYGWIN__) +# define GLAPI extern +# endif +#endif +/* */ +#ifndef CALLBACK +#define GLEW_CALLBACK_DEFINED +# if defined(__MINGW32__) || defined(__CYGWIN__) +# define CALLBACK __attribute__ ((__stdcall__)) +# elif (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +#endif +/* and */ +#ifndef WINGDIAPI +#define GLEW_WINGDIAPI_DEFINED +#define WINGDIAPI __declspec(dllimport) +#endif +/* */ +#if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(_WCHAR_T_DEFINED) +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +#endif +/* */ +#if !defined(_W64) +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && defined(_MSC_VER) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif +#if !defined(_PTRDIFF_T_DEFINED) && !defined(_PTRDIFF_T_) && !defined(__MINGW64__) +# ifdef _WIN64 +typedef __int64 ptrdiff_t; +# else +typedef _W64 int ptrdiff_t; +# endif +# define _PTRDIFF_T_DEFINED +# define _PTRDIFF_T_ +#endif + +#ifndef GLAPI +# if defined(__MINGW32__) || defined(__CYGWIN__) +# define GLAPI extern +# else +# define GLAPI WINGDIAPI +# endif +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +/* + * GLEW_STATIC is defined for static library. + * GLEW_BUILD is defined for building the DLL library. + */ + +#ifdef GLEW_STATIC +# define GLEWAPI extern +#else +# ifdef GLEW_BUILD +# define GLEWAPI extern __declspec(dllexport) +# else +# define GLEWAPI extern __declspec(dllimport) +# endif +#endif + +#else /* _UNIX */ + +/* + * Needed for ptrdiff_t in turn needed by VBO. This is defined by ISO + * C. On my system, this amounts to _3 lines_ of included code, all of + * them pretty much harmless. If you know of a way of detecting 32 vs + * 64 _targets_ at compile time you are free to replace this with + * something that's portable. For now, _this_ is the portable solution. + * (mem, 2004-01-04) + */ + +#include + +/* SGI MIPSPro doesn't like stdint.h in C++ mode */ +/* ID: 3376260 Solaris 9 has inttypes.h, but not stdint.h */ + +#if (defined(__sgi) || defined(__sun)) && !defined(__GNUC__) +#include +#else +#include +#endif + +#define GLEW_APIENTRY_DEFINED +#define APIENTRY + +/* + * GLEW_STATIC is defined for static library. + */ + +#ifdef GLEW_STATIC +# define GLEWAPI extern +#else +# if defined(__GNUC__) && __GNUC__>=4 +# define GLEWAPI extern __attribute__ ((visibility("default"))) +# elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) +# define GLEWAPI extern __global +# else +# define GLEWAPI extern +# endif +#endif + +/* */ +#ifndef GLAPI +#define GLAPI extern +#endif +#ifndef GLAPIENTRY +#define GLAPIENTRY +#endif + +#endif /* _WIN32 */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------- GL_VERSION_1_1 ---------------------------- */ + +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 + +typedef unsigned int GLenum; +typedef unsigned int GLbitfield; +typedef unsigned int GLuint; +typedef int GLint; +typedef int GLsizei; +typedef unsigned char GLboolean; +typedef signed char GLbyte; +typedef short GLshort; +typedef unsigned char GLubyte; +typedef unsigned short GLushort; +typedef unsigned long GLulong; +typedef float GLfloat; +typedef float GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void GLvoid; +#if defined(_MSC_VER) && _MSC_VER < 1400 +typedef __int64 GLint64EXT; +typedef unsigned __int64 GLuint64EXT; +#elif defined(_MSC_VER) || defined(__BORLANDC__) +typedef signed long long GLint64EXT; +typedef unsigned long long GLuint64EXT; +#else +# if defined(__MINGW32__) || defined(__CYGWIN__) +#include +# endif +typedef int64_t GLint64EXT; +typedef uint64_t GLuint64EXT; +#endif +typedef GLint64EXT GLint64; +typedef GLuint64EXT GLuint64; +typedef struct __GLsync *GLsync; + +typedef char GLchar; + +#define GL_ZERO 0 +#define GL_FALSE 0 +#define GL_LOGIC_OP 0x0BF1 +#define GL_NONE 0 +#define GL_TEXTURE_COMPONENTS 0x1003 +#define GL_NO_ERROR 0 +#define GL_POINTS 0x0000 +#define GL_CURRENT_BIT 0x00000001 +#define GL_TRUE 1 +#define GL_ONE 1 +#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_POINT_BIT 0x00000002 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_LINE_STRIP 0x0003 +#define GL_LINE_BIT 0x00000004 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_QUADS 0x0007 +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON 0x0009 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_ACCUM 0x0100 +#define GL_LOAD 0x0101 +#define GL_RETURN 0x0102 +#define GL_MULT 0x0103 +#define GL_ADD 0x0104 +#define GL_NEVER 0x0200 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_EXP 0x0800 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_EXP2 0x0801 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_COEFF 0x0A00 +#define GL_ORDER 0x0A01 +#define GL_DOMAIN 0x0A02 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_POINT_SMOOTH 0x0B10 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LIST_MODE 0x0B30 +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_LIST_BASE 0x0B32 +#define GL_LIST_INDEX 0x0B33 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_SHADE_MODEL 0x0B54 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_FOG 0x0B60 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_COLOR 0x0B66 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_MATRIX_MODE 0x0BA0 +#define GL_NORMALIZE 0x0BA1 +#define GL_VIEWPORT 0x0BA2 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_FUNC 0x0BC1 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_INDEX_MODE 0x0C30 +#define GL_RGBA_MODE 0x0C31 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_RENDER_MODE 0x0C40 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_FOG_HINT 0x0C54 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_INDEX_BITS 0x0D51 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 +#define GL_SELECTION_BUFFER_POINTER 0x0DF3 +#define GL_SELECTION_BUFFER_SIZE 0x0DF4 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_COMPILE 0x1300 +#define GL_COMPILE_AND_EXECUTE 0x1301 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 +#define GL_DOUBLE 0x140A +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_EMISSION 0x1600 +#define GL_SHININESS 0x1601 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_COLOR_INDEX 0x1900 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_BITMAP 0x1A00 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_RENDER 0x1C00 +#define GL_FEEDBACK 0x1C01 +#define GL_SELECT 0x1C02 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_S 0x2000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_MODULATE 0x2100 +#define GL_DECAL 0x2101 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_ENV 0x2300 +#define GL_EYE_LINEAR 0x2400 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_SPHERE_MAP 0x2402 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_PLANE 0x2502 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_CLAMP 0x2900 +#define GL_REPEAT 0x2901 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_R3_G3_B2 0x2A10 +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 +#define GL_LIGHT0 0x4000 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_HINT_BIT 0x00008000 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0x000fffff +#define GL_CLIENT_ALL_ATTRIB_BITS 0xffffffff + +GLAPI void GLAPIENTRY glAccum (GLenum op, GLfloat value); +GLAPI void GLAPIENTRY glAlphaFunc (GLenum func, GLclampf ref); +GLAPI GLboolean GLAPIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences); +GLAPI void GLAPIENTRY glArrayElement (GLint i); +GLAPI void GLAPIENTRY glBegin (GLenum mode); +GLAPI void GLAPIENTRY glBindTexture (GLenum target, GLuint texture); +GLAPI void GLAPIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); +GLAPI void GLAPIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor); +GLAPI void GLAPIENTRY glCallList (GLuint list); +GLAPI void GLAPIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists); +GLAPI void GLAPIENTRY glClear (GLbitfield mask); +GLAPI void GLAPIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI void GLAPIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +GLAPI void GLAPIENTRY glClearDepth (GLclampd depth); +GLAPI void GLAPIENTRY glClearIndex (GLfloat c); +GLAPI void GLAPIENTRY glClearStencil (GLint s); +GLAPI void GLAPIENTRY glClipPlane (GLenum plane, const GLdouble *equation); +GLAPI void GLAPIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue); +GLAPI void GLAPIENTRY glColor3bv (const GLbyte *v); +GLAPI void GLAPIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue); +GLAPI void GLAPIENTRY glColor3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue); +GLAPI void GLAPIENTRY glColor3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glColor3i (GLint red, GLint green, GLint blue); +GLAPI void GLAPIENTRY glColor3iv (const GLint *v); +GLAPI void GLAPIENTRY glColor3s (GLshort red, GLshort green, GLshort blue); +GLAPI void GLAPIENTRY glColor3sv (const GLshort *v); +GLAPI void GLAPIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue); +GLAPI void GLAPIENTRY glColor3ubv (const GLubyte *v); +GLAPI void GLAPIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue); +GLAPI void GLAPIENTRY glColor3uiv (const GLuint *v); +GLAPI void GLAPIENTRY glColor3us (GLushort red, GLushort green, GLushort blue); +GLAPI void GLAPIENTRY glColor3usv (const GLushort *v); +GLAPI void GLAPIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +GLAPI void GLAPIENTRY glColor4bv (const GLbyte *v); +GLAPI void GLAPIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +GLAPI void GLAPIENTRY glColor4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI void GLAPIENTRY glColor4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha); +GLAPI void GLAPIENTRY glColor4iv (const GLint *v); +GLAPI void GLAPIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha); +GLAPI void GLAPIENTRY glColor4sv (const GLshort *v); +GLAPI void GLAPIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +GLAPI void GLAPIENTRY glColor4ubv (const GLubyte *v); +GLAPI void GLAPIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha); +GLAPI void GLAPIENTRY glColor4uiv (const GLuint *v); +GLAPI void GLAPIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha); +GLAPI void GLAPIENTRY glColor4usv (const GLushort *v); +GLAPI void GLAPIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI void GLAPIENTRY glColorMaterial (GLenum face, GLenum mode); +GLAPI void GLAPIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +GLAPI void GLAPIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI void GLAPIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI void GLAPIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI void GLAPIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glCullFace (GLenum mode); +GLAPI void GLAPIENTRY glDeleteLists (GLuint list, GLsizei range); +GLAPI void GLAPIENTRY glDeleteTextures (GLsizei n, const GLuint *textures); +GLAPI void GLAPIENTRY glDepthFunc (GLenum func); +GLAPI void GLAPIENTRY glDepthMask (GLboolean flag); +GLAPI void GLAPIENTRY glDepthRange (GLclampd zNear, GLclampd zFar); +GLAPI void GLAPIENTRY glDisable (GLenum cap); +GLAPI void GLAPIENTRY glDisableClientState (GLenum array); +GLAPI void GLAPIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count); +GLAPI void GLAPIENTRY glDrawBuffer (GLenum mode); +GLAPI void GLAPIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); +GLAPI void GLAPIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glEdgeFlag (GLboolean flag); +GLAPI void GLAPIENTRY glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glEdgeFlagv (const GLboolean *flag); +GLAPI void GLAPIENTRY glEnable (GLenum cap); +GLAPI void GLAPIENTRY glEnableClientState (GLenum array); +GLAPI void GLAPIENTRY glEnd (void); +GLAPI void GLAPIENTRY glEndList (void); +GLAPI void GLAPIENTRY glEvalCoord1d (GLdouble u); +GLAPI void GLAPIENTRY glEvalCoord1dv (const GLdouble *u); +GLAPI void GLAPIENTRY glEvalCoord1f (GLfloat u); +GLAPI void GLAPIENTRY glEvalCoord1fv (const GLfloat *u); +GLAPI void GLAPIENTRY glEvalCoord2d (GLdouble u, GLdouble v); +GLAPI void GLAPIENTRY glEvalCoord2dv (const GLdouble *u); +GLAPI void GLAPIENTRY glEvalCoord2f (GLfloat u, GLfloat v); +GLAPI void GLAPIENTRY glEvalCoord2fv (const GLfloat *u); +GLAPI void GLAPIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2); +GLAPI void GLAPIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +GLAPI void GLAPIENTRY glEvalPoint1 (GLint i); +GLAPI void GLAPIENTRY glEvalPoint2 (GLint i, GLint j); +GLAPI void GLAPIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer); +GLAPI void GLAPIENTRY glFinish (void); +GLAPI void GLAPIENTRY glFlush (void); +GLAPI void GLAPIENTRY glFogf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glFogfv (GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glFogi (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glFogiv (GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glFrontFace (GLenum mode); +GLAPI void GLAPIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI GLuint GLAPIENTRY glGenLists (GLsizei range); +GLAPI void GLAPIENTRY glGenTextures (GLsizei n, GLuint *textures); +GLAPI void GLAPIENTRY glGetBooleanv (GLenum pname, GLboolean *params); +GLAPI void GLAPIENTRY glGetClipPlane (GLenum plane, GLdouble *equation); +GLAPI void GLAPIENTRY glGetDoublev (GLenum pname, GLdouble *params); +GLAPI GLenum GLAPIENTRY glGetError (void); +GLAPI void GLAPIENTRY glGetFloatv (GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetIntegerv (GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v); +GLAPI void GLAPIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v); +GLAPI void GLAPIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v); +GLAPI void GLAPIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetPixelMapfv (GLenum map, GLfloat *values); +GLAPI void GLAPIENTRY glGetPixelMapuiv (GLenum map, GLuint *values); +GLAPI void GLAPIENTRY glGetPixelMapusv (GLenum map, GLushort *values); +GLAPI void GLAPIENTRY glGetPointerv (GLenum pname, GLvoid* *params); +GLAPI void GLAPIENTRY glGetPolygonStipple (GLubyte *mask); +GLAPI const GLubyte * GLAPIENTRY glGetString (GLenum name); +GLAPI void GLAPIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params); +GLAPI void GLAPIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); +GLAPI void GLAPIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glHint (GLenum target, GLenum mode); +GLAPI void GLAPIENTRY glIndexMask (GLuint mask); +GLAPI void GLAPIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glIndexd (GLdouble c); +GLAPI void GLAPIENTRY glIndexdv (const GLdouble *c); +GLAPI void GLAPIENTRY glIndexf (GLfloat c); +GLAPI void GLAPIENTRY glIndexfv (const GLfloat *c); +GLAPI void GLAPIENTRY glIndexi (GLint c); +GLAPI void GLAPIENTRY glIndexiv (const GLint *c); +GLAPI void GLAPIENTRY glIndexs (GLshort c); +GLAPI void GLAPIENTRY glIndexsv (const GLshort *c); +GLAPI void GLAPIENTRY glIndexub (GLubyte c); +GLAPI void GLAPIENTRY glIndexubv (const GLubyte *c); +GLAPI void GLAPIENTRY glInitNames (void); +GLAPI void GLAPIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer); +GLAPI GLboolean GLAPIENTRY glIsEnabled (GLenum cap); +GLAPI GLboolean GLAPIENTRY glIsList (GLuint list); +GLAPI GLboolean GLAPIENTRY glIsTexture (GLuint texture); +GLAPI void GLAPIENTRY glLightModelf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glLightModelfv (GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glLightModeli (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glLightModeliv (GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glLightf (GLenum light, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glLighti (GLenum light, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glLineStipple (GLint factor, GLushort pattern); +GLAPI void GLAPIENTRY glLineWidth (GLfloat width); +GLAPI void GLAPIENTRY glListBase (GLuint base); +GLAPI void GLAPIENTRY glLoadIdentity (void); +GLAPI void GLAPIENTRY glLoadMatrixd (const GLdouble *m); +GLAPI void GLAPIENTRY glLoadMatrixf (const GLfloat *m); +GLAPI void GLAPIENTRY glLoadName (GLuint name); +GLAPI void GLAPIENTRY glLogicOp (GLenum opcode); +GLAPI void GLAPIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); +GLAPI void GLAPIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); +GLAPI void GLAPIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); +GLAPI void GLAPIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); +GLAPI void GLAPIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2); +GLAPI void GLAPIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2); +GLAPI void GLAPIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +GLAPI void GLAPIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +GLAPI void GLAPIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glMateriali (GLenum face, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glMatrixMode (GLenum mode); +GLAPI void GLAPIENTRY glMultMatrixd (const GLdouble *m); +GLAPI void GLAPIENTRY glMultMatrixf (const GLfloat *m); +GLAPI void GLAPIENTRY glNewList (GLuint list, GLenum mode); +GLAPI void GLAPIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz); +GLAPI void GLAPIENTRY glNormal3bv (const GLbyte *v); +GLAPI void GLAPIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz); +GLAPI void GLAPIENTRY glNormal3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz); +GLAPI void GLAPIENTRY glNormal3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glNormal3i (GLint nx, GLint ny, GLint nz); +GLAPI void GLAPIENTRY glNormal3iv (const GLint *v); +GLAPI void GLAPIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz); +GLAPI void GLAPIENTRY glNormal3sv (const GLshort *v); +GLAPI void GLAPIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI void GLAPIENTRY glPassThrough (GLfloat token); +GLAPI void GLAPIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values); +GLAPI void GLAPIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values); +GLAPI void GLAPIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values); +GLAPI void GLAPIENTRY glPixelStoref (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glPixelStorei (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glPixelTransferf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glPixelTransferi (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor); +GLAPI void GLAPIENTRY glPointSize (GLfloat size); +GLAPI void GLAPIENTRY glPolygonMode (GLenum face, GLenum mode); +GLAPI void GLAPIENTRY glPolygonOffset (GLfloat factor, GLfloat units); +GLAPI void GLAPIENTRY glPolygonStipple (const GLubyte *mask); +GLAPI void GLAPIENTRY glPopAttrib (void); +GLAPI void GLAPIENTRY glPopClientAttrib (void); +GLAPI void GLAPIENTRY glPopMatrix (void); +GLAPI void GLAPIENTRY glPopName (void); +GLAPI void GLAPIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities); +GLAPI void GLAPIENTRY glPushAttrib (GLbitfield mask); +GLAPI void GLAPIENTRY glPushClientAttrib (GLbitfield mask); +GLAPI void GLAPIENTRY glPushMatrix (void); +GLAPI void GLAPIENTRY glPushName (GLuint name); +GLAPI void GLAPIENTRY glRasterPos2d (GLdouble x, GLdouble y); +GLAPI void GLAPIENTRY glRasterPos2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos2f (GLfloat x, GLfloat y); +GLAPI void GLAPIENTRY glRasterPos2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos2i (GLint x, GLint y); +GLAPI void GLAPIENTRY glRasterPos2iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos2s (GLshort x, GLshort y); +GLAPI void GLAPIENTRY glRasterPos2sv (const GLshort *v); +GLAPI void GLAPIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glRasterPos3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glRasterPos3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos3i (GLint x, GLint y, GLint z); +GLAPI void GLAPIENTRY glRasterPos3iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z); +GLAPI void GLAPIENTRY glRasterPos3sv (const GLshort *v); +GLAPI void GLAPIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI void GLAPIENTRY glRasterPos4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI void GLAPIENTRY glRasterPos4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w); +GLAPI void GLAPIENTRY glRasterPos4iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI void GLAPIENTRY glRasterPos4sv (const GLshort *v); +GLAPI void GLAPIENTRY glReadBuffer (GLenum mode); +GLAPI void GLAPIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); +GLAPI void GLAPIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +GLAPI void GLAPIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2); +GLAPI void GLAPIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +GLAPI void GLAPIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2); +GLAPI void GLAPIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2); +GLAPI void GLAPIENTRY glRectiv (const GLint *v1, const GLint *v2); +GLAPI void GLAPIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2); +GLAPI void GLAPIENTRY glRectsv (const GLshort *v1, const GLshort *v2); +GLAPI GLint GLAPIENTRY glRenderMode (GLenum mode); +GLAPI void GLAPIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glSelectBuffer (GLsizei size, GLuint *buffer); +GLAPI void GLAPIENTRY glShadeModel (GLenum mode); +GLAPI void GLAPIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask); +GLAPI void GLAPIENTRY glStencilMask (GLuint mask); +GLAPI void GLAPIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass); +GLAPI void GLAPIENTRY glTexCoord1d (GLdouble s); +GLAPI void GLAPIENTRY glTexCoord1dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord1f (GLfloat s); +GLAPI void GLAPIENTRY glTexCoord1fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord1i (GLint s); +GLAPI void GLAPIENTRY glTexCoord1iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord1s (GLshort s); +GLAPI void GLAPIENTRY glTexCoord1sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord2d (GLdouble s, GLdouble t); +GLAPI void GLAPIENTRY glTexCoord2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord2f (GLfloat s, GLfloat t); +GLAPI void GLAPIENTRY glTexCoord2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord2i (GLint s, GLint t); +GLAPI void GLAPIENTRY glTexCoord2iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord2s (GLshort s, GLshort t); +GLAPI void GLAPIENTRY glTexCoord2sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r); +GLAPI void GLAPIENTRY glTexCoord3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r); +GLAPI void GLAPIENTRY glTexCoord3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord3i (GLint s, GLint t, GLint r); +GLAPI void GLAPIENTRY glTexCoord3iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r); +GLAPI void GLAPIENTRY glTexCoord3sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI void GLAPIENTRY glTexCoord4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI void GLAPIENTRY glTexCoord4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q); +GLAPI void GLAPIENTRY glTexCoord4iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI void GLAPIENTRY glTexCoord4sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param); +GLAPI void GLAPIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params); +GLAPI void GLAPIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glVertex2d (GLdouble x, GLdouble y); +GLAPI void GLAPIENTRY glVertex2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex2f (GLfloat x, GLfloat y); +GLAPI void GLAPIENTRY glVertex2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex2i (GLint x, GLint y); +GLAPI void GLAPIENTRY glVertex2iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex2s (GLshort x, GLshort y); +GLAPI void GLAPIENTRY glVertex2sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glVertex3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glVertex3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex3i (GLint x, GLint y, GLint z); +GLAPI void GLAPIENTRY glVertex3iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex3s (GLshort x, GLshort y, GLshort z); +GLAPI void GLAPIENTRY glVertex3sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI void GLAPIENTRY glVertex4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI void GLAPIENTRY glVertex4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w); +GLAPI void GLAPIENTRY glVertex4iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI void GLAPIENTRY glVertex4sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height); + +#define GLEW_VERSION_1_1 GLEW_GET_VAR(__GLEW_VERSION_1_1) + +#endif /* GL_VERSION_1_1 */ + +/* ---------------------------------- GLU ---------------------------------- */ + +#ifndef GLEW_NO_GLU +/* this is where we can safely include GLU */ +# if defined(__APPLE__) && defined(__MACH__) +# include +# else +# include +# endif +#endif + +/* ----------------------------- GL_VERSION_1_2 ---------------------------- */ + +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 + +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_RESCALE_NORMAL 0x803A +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E + +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); + +#define glCopyTexSubImage3D GLEW_GET_FUN(__glewCopyTexSubImage3D) +#define glDrawRangeElements GLEW_GET_FUN(__glewDrawRangeElements) +#define glTexImage3D GLEW_GET_FUN(__glewTexImage3D) +#define glTexSubImage3D GLEW_GET_FUN(__glewTexSubImage3D) + +#define GLEW_VERSION_1_2 GLEW_GET_VAR(__GLEW_VERSION_1_2) + +#endif /* GL_VERSION_1_2 */ + +/* ---------------------------- GL_VERSION_1_2_1 --------------------------- */ + +#ifndef GL_VERSION_1_2_1 +#define GL_VERSION_1_2_1 1 + +#define GLEW_VERSION_1_2_1 GLEW_GET_VAR(__GLEW_VERSION_1_2_1) + +#endif /* GL_VERSION_1_2_1 */ + +/* ----------------------------- GL_VERSION_1_3 ---------------------------- */ + +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 + +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_SUBTRACT 0x84E7 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_MULTISAMPLE_BIT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint lod, GLvoid *img); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); + +#define glActiveTexture GLEW_GET_FUN(__glewActiveTexture) +#define glClientActiveTexture GLEW_GET_FUN(__glewClientActiveTexture) +#define glCompressedTexImage1D GLEW_GET_FUN(__glewCompressedTexImage1D) +#define glCompressedTexImage2D GLEW_GET_FUN(__glewCompressedTexImage2D) +#define glCompressedTexImage3D GLEW_GET_FUN(__glewCompressedTexImage3D) +#define glCompressedTexSubImage1D GLEW_GET_FUN(__glewCompressedTexSubImage1D) +#define glCompressedTexSubImage2D GLEW_GET_FUN(__glewCompressedTexSubImage2D) +#define glCompressedTexSubImage3D GLEW_GET_FUN(__glewCompressedTexSubImage3D) +#define glGetCompressedTexImage GLEW_GET_FUN(__glewGetCompressedTexImage) +#define glLoadTransposeMatrixd GLEW_GET_FUN(__glewLoadTransposeMatrixd) +#define glLoadTransposeMatrixf GLEW_GET_FUN(__glewLoadTransposeMatrixf) +#define glMultTransposeMatrixd GLEW_GET_FUN(__glewMultTransposeMatrixd) +#define glMultTransposeMatrixf GLEW_GET_FUN(__glewMultTransposeMatrixf) +#define glMultiTexCoord1d GLEW_GET_FUN(__glewMultiTexCoord1d) +#define glMultiTexCoord1dv GLEW_GET_FUN(__glewMultiTexCoord1dv) +#define glMultiTexCoord1f GLEW_GET_FUN(__glewMultiTexCoord1f) +#define glMultiTexCoord1fv GLEW_GET_FUN(__glewMultiTexCoord1fv) +#define glMultiTexCoord1i GLEW_GET_FUN(__glewMultiTexCoord1i) +#define glMultiTexCoord1iv GLEW_GET_FUN(__glewMultiTexCoord1iv) +#define glMultiTexCoord1s GLEW_GET_FUN(__glewMultiTexCoord1s) +#define glMultiTexCoord1sv GLEW_GET_FUN(__glewMultiTexCoord1sv) +#define glMultiTexCoord2d GLEW_GET_FUN(__glewMultiTexCoord2d) +#define glMultiTexCoord2dv GLEW_GET_FUN(__glewMultiTexCoord2dv) +#define glMultiTexCoord2f GLEW_GET_FUN(__glewMultiTexCoord2f) +#define glMultiTexCoord2fv GLEW_GET_FUN(__glewMultiTexCoord2fv) +#define glMultiTexCoord2i GLEW_GET_FUN(__glewMultiTexCoord2i) +#define glMultiTexCoord2iv GLEW_GET_FUN(__glewMultiTexCoord2iv) +#define glMultiTexCoord2s GLEW_GET_FUN(__glewMultiTexCoord2s) +#define glMultiTexCoord2sv GLEW_GET_FUN(__glewMultiTexCoord2sv) +#define glMultiTexCoord3d GLEW_GET_FUN(__glewMultiTexCoord3d) +#define glMultiTexCoord3dv GLEW_GET_FUN(__glewMultiTexCoord3dv) +#define glMultiTexCoord3f GLEW_GET_FUN(__glewMultiTexCoord3f) +#define glMultiTexCoord3fv GLEW_GET_FUN(__glewMultiTexCoord3fv) +#define glMultiTexCoord3i GLEW_GET_FUN(__glewMultiTexCoord3i) +#define glMultiTexCoord3iv GLEW_GET_FUN(__glewMultiTexCoord3iv) +#define glMultiTexCoord3s GLEW_GET_FUN(__glewMultiTexCoord3s) +#define glMultiTexCoord3sv GLEW_GET_FUN(__glewMultiTexCoord3sv) +#define glMultiTexCoord4d GLEW_GET_FUN(__glewMultiTexCoord4d) +#define glMultiTexCoord4dv GLEW_GET_FUN(__glewMultiTexCoord4dv) +#define glMultiTexCoord4f GLEW_GET_FUN(__glewMultiTexCoord4f) +#define glMultiTexCoord4fv GLEW_GET_FUN(__glewMultiTexCoord4fv) +#define glMultiTexCoord4i GLEW_GET_FUN(__glewMultiTexCoord4i) +#define glMultiTexCoord4iv GLEW_GET_FUN(__glewMultiTexCoord4iv) +#define glMultiTexCoord4s GLEW_GET_FUN(__glewMultiTexCoord4s) +#define glMultiTexCoord4sv GLEW_GET_FUN(__glewMultiTexCoord4sv) +#define glSampleCoverage GLEW_GET_FUN(__glewSampleCoverage) + +#define GLEW_VERSION_1_3 GLEW_GET_VAR(__GLEW_VERSION_1_3) + +#endif /* GL_VERSION_1_3 */ + +/* ----------------------------- GL_VERSION_1_4 ---------------------------- */ + +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 + +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_COMPARE_R_TO_TEXTURE 0x884E + +typedef void (GLAPIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVPROC) (const GLdouble *coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVPROC) (const GLfloat *coord); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVPROC) (const GLdouble *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVPROC) (const GLfloat *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVPROC) (const GLint *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVPROC) (const GLshort *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVPROC) (const GLdouble *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVPROC) (const GLfloat *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVPROC) (const GLint *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVPROC) (const GLshort *p); + +#define glBlendColor GLEW_GET_FUN(__glewBlendColor) +#define glBlendEquation GLEW_GET_FUN(__glewBlendEquation) +#define glBlendFuncSeparate GLEW_GET_FUN(__glewBlendFuncSeparate) +#define glFogCoordPointer GLEW_GET_FUN(__glewFogCoordPointer) +#define glFogCoordd GLEW_GET_FUN(__glewFogCoordd) +#define glFogCoorddv GLEW_GET_FUN(__glewFogCoorddv) +#define glFogCoordf GLEW_GET_FUN(__glewFogCoordf) +#define glFogCoordfv GLEW_GET_FUN(__glewFogCoordfv) +#define glMultiDrawArrays GLEW_GET_FUN(__glewMultiDrawArrays) +#define glMultiDrawElements GLEW_GET_FUN(__glewMultiDrawElements) +#define glPointParameterf GLEW_GET_FUN(__glewPointParameterf) +#define glPointParameterfv GLEW_GET_FUN(__glewPointParameterfv) +#define glPointParameteri GLEW_GET_FUN(__glewPointParameteri) +#define glPointParameteriv GLEW_GET_FUN(__glewPointParameteriv) +#define glSecondaryColor3b GLEW_GET_FUN(__glewSecondaryColor3b) +#define glSecondaryColor3bv GLEW_GET_FUN(__glewSecondaryColor3bv) +#define glSecondaryColor3d GLEW_GET_FUN(__glewSecondaryColor3d) +#define glSecondaryColor3dv GLEW_GET_FUN(__glewSecondaryColor3dv) +#define glSecondaryColor3f GLEW_GET_FUN(__glewSecondaryColor3f) +#define glSecondaryColor3fv GLEW_GET_FUN(__glewSecondaryColor3fv) +#define glSecondaryColor3i GLEW_GET_FUN(__glewSecondaryColor3i) +#define glSecondaryColor3iv GLEW_GET_FUN(__glewSecondaryColor3iv) +#define glSecondaryColor3s GLEW_GET_FUN(__glewSecondaryColor3s) +#define glSecondaryColor3sv GLEW_GET_FUN(__glewSecondaryColor3sv) +#define glSecondaryColor3ub GLEW_GET_FUN(__glewSecondaryColor3ub) +#define glSecondaryColor3ubv GLEW_GET_FUN(__glewSecondaryColor3ubv) +#define glSecondaryColor3ui GLEW_GET_FUN(__glewSecondaryColor3ui) +#define glSecondaryColor3uiv GLEW_GET_FUN(__glewSecondaryColor3uiv) +#define glSecondaryColor3us GLEW_GET_FUN(__glewSecondaryColor3us) +#define glSecondaryColor3usv GLEW_GET_FUN(__glewSecondaryColor3usv) +#define glSecondaryColorPointer GLEW_GET_FUN(__glewSecondaryColorPointer) +#define glWindowPos2d GLEW_GET_FUN(__glewWindowPos2d) +#define glWindowPos2dv GLEW_GET_FUN(__glewWindowPos2dv) +#define glWindowPos2f GLEW_GET_FUN(__glewWindowPos2f) +#define glWindowPos2fv GLEW_GET_FUN(__glewWindowPos2fv) +#define glWindowPos2i GLEW_GET_FUN(__glewWindowPos2i) +#define glWindowPos2iv GLEW_GET_FUN(__glewWindowPos2iv) +#define glWindowPos2s GLEW_GET_FUN(__glewWindowPos2s) +#define glWindowPos2sv GLEW_GET_FUN(__glewWindowPos2sv) +#define glWindowPos3d GLEW_GET_FUN(__glewWindowPos3d) +#define glWindowPos3dv GLEW_GET_FUN(__glewWindowPos3dv) +#define glWindowPos3f GLEW_GET_FUN(__glewWindowPos3f) +#define glWindowPos3fv GLEW_GET_FUN(__glewWindowPos3fv) +#define glWindowPos3i GLEW_GET_FUN(__glewWindowPos3i) +#define glWindowPos3iv GLEW_GET_FUN(__glewWindowPos3iv) +#define glWindowPos3s GLEW_GET_FUN(__glewWindowPos3s) +#define glWindowPos3sv GLEW_GET_FUN(__glewWindowPos3sv) + +#define GLEW_VERSION_1_4 GLEW_GET_VAR(__GLEW_VERSION_1_4) + +#endif /* GL_VERSION_1_4 */ + +/* ----------------------------- GL_VERSION_1_5 ---------------------------- */ + +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 + +#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE +#define GL_FOG_COORD GL_FOG_COORDINATE +#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY +#define GL_SRC0_RGB GL_SOURCE0_RGB +#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER +#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE +#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA +#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE +#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE +#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA +#define GL_SRC1_RGB GL_SOURCE1_RGB +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING +#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA +#define GL_SRC2_RGB GL_SOURCE2_RGB +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 + +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDQUERYPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSPROC) (GLsizei n, GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGENQUERIESPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERPROC) (GLuint buffer); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYPROC) (GLuint id); +typedef GLvoid* (GLAPIENTRY * PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERPROC) (GLenum target); + +#define glBeginQuery GLEW_GET_FUN(__glewBeginQuery) +#define glBindBuffer GLEW_GET_FUN(__glewBindBuffer) +#define glBufferData GLEW_GET_FUN(__glewBufferData) +#define glBufferSubData GLEW_GET_FUN(__glewBufferSubData) +#define glDeleteBuffers GLEW_GET_FUN(__glewDeleteBuffers) +#define glDeleteQueries GLEW_GET_FUN(__glewDeleteQueries) +#define glEndQuery GLEW_GET_FUN(__glewEndQuery) +#define glGenBuffers GLEW_GET_FUN(__glewGenBuffers) +#define glGenQueries GLEW_GET_FUN(__glewGenQueries) +#define glGetBufferParameteriv GLEW_GET_FUN(__glewGetBufferParameteriv) +#define glGetBufferPointerv GLEW_GET_FUN(__glewGetBufferPointerv) +#define glGetBufferSubData GLEW_GET_FUN(__glewGetBufferSubData) +#define glGetQueryObjectiv GLEW_GET_FUN(__glewGetQueryObjectiv) +#define glGetQueryObjectuiv GLEW_GET_FUN(__glewGetQueryObjectuiv) +#define glGetQueryiv GLEW_GET_FUN(__glewGetQueryiv) +#define glIsBuffer GLEW_GET_FUN(__glewIsBuffer) +#define glIsQuery GLEW_GET_FUN(__glewIsQuery) +#define glMapBuffer GLEW_GET_FUN(__glewMapBuffer) +#define glUnmapBuffer GLEW_GET_FUN(__glewUnmapBuffer) + +#define GLEW_VERSION_1_5 GLEW_GET_VAR(__GLEW_VERSION_1_5) + +#endif /* GL_VERSION_1_5 */ + +/* ----------------------------- GL_VERSION_2_0 ---------------------------- */ + +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 + +#define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 + +typedef void (GLAPIENTRY * PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum, GLenum); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader); +typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRAMPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROC) (GLenum type); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLDELETESHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum* bufs); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEPROC) (GLuint obj, GLsizei maxLength, GLsizei* length, GLchar* source); +typedef void (GLAPIENTRY * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint* param); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint, GLenum, GLvoid**); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVPROC) (GLuint, GLenum, GLdouble*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVPROC) (GLuint, GLenum, GLfloat*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVPROC) (GLuint, GLenum, GLint*); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPROC) (GLuint program); +typedef GLboolean (GLAPIENTRY * PFNGLISSHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar** strings, const GLint* lengths); +typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILMASKSEPARATEPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer); + +#define glAttachShader GLEW_GET_FUN(__glewAttachShader) +#define glBindAttribLocation GLEW_GET_FUN(__glewBindAttribLocation) +#define glBlendEquationSeparate GLEW_GET_FUN(__glewBlendEquationSeparate) +#define glCompileShader GLEW_GET_FUN(__glewCompileShader) +#define glCreateProgram GLEW_GET_FUN(__glewCreateProgram) +#define glCreateShader GLEW_GET_FUN(__glewCreateShader) +#define glDeleteProgram GLEW_GET_FUN(__glewDeleteProgram) +#define glDeleteShader GLEW_GET_FUN(__glewDeleteShader) +#define glDetachShader GLEW_GET_FUN(__glewDetachShader) +#define glDisableVertexAttribArray GLEW_GET_FUN(__glewDisableVertexAttribArray) +#define glDrawBuffers GLEW_GET_FUN(__glewDrawBuffers) +#define glEnableVertexAttribArray GLEW_GET_FUN(__glewEnableVertexAttribArray) +#define glGetActiveAttrib GLEW_GET_FUN(__glewGetActiveAttrib) +#define glGetActiveUniform GLEW_GET_FUN(__glewGetActiveUniform) +#define glGetAttachedShaders GLEW_GET_FUN(__glewGetAttachedShaders) +#define glGetAttribLocation GLEW_GET_FUN(__glewGetAttribLocation) +#define glGetProgramInfoLog GLEW_GET_FUN(__glewGetProgramInfoLog) +#define glGetProgramiv GLEW_GET_FUN(__glewGetProgramiv) +#define glGetShaderInfoLog GLEW_GET_FUN(__glewGetShaderInfoLog) +#define glGetShaderSource GLEW_GET_FUN(__glewGetShaderSource) +#define glGetShaderiv GLEW_GET_FUN(__glewGetShaderiv) +#define glGetUniformLocation GLEW_GET_FUN(__glewGetUniformLocation) +#define glGetUniformfv GLEW_GET_FUN(__glewGetUniformfv) +#define glGetUniformiv GLEW_GET_FUN(__glewGetUniformiv) +#define glGetVertexAttribPointerv GLEW_GET_FUN(__glewGetVertexAttribPointerv) +#define glGetVertexAttribdv GLEW_GET_FUN(__glewGetVertexAttribdv) +#define glGetVertexAttribfv GLEW_GET_FUN(__glewGetVertexAttribfv) +#define glGetVertexAttribiv GLEW_GET_FUN(__glewGetVertexAttribiv) +#define glIsProgram GLEW_GET_FUN(__glewIsProgram) +#define glIsShader GLEW_GET_FUN(__glewIsShader) +#define glLinkProgram GLEW_GET_FUN(__glewLinkProgram) +#define glShaderSource GLEW_GET_FUN(__glewShaderSource) +#define glStencilFuncSeparate GLEW_GET_FUN(__glewStencilFuncSeparate) +#define glStencilMaskSeparate GLEW_GET_FUN(__glewStencilMaskSeparate) +#define glStencilOpSeparate GLEW_GET_FUN(__glewStencilOpSeparate) +#define glUniform1f GLEW_GET_FUN(__glewUniform1f) +#define glUniform1fv GLEW_GET_FUN(__glewUniform1fv) +#define glUniform1i GLEW_GET_FUN(__glewUniform1i) +#define glUniform1iv GLEW_GET_FUN(__glewUniform1iv) +#define glUniform2f GLEW_GET_FUN(__glewUniform2f) +#define glUniform2fv GLEW_GET_FUN(__glewUniform2fv) +#define glUniform2i GLEW_GET_FUN(__glewUniform2i) +#define glUniform2iv GLEW_GET_FUN(__glewUniform2iv) +#define glUniform3f GLEW_GET_FUN(__glewUniform3f) +#define glUniform3fv GLEW_GET_FUN(__glewUniform3fv) +#define glUniform3i GLEW_GET_FUN(__glewUniform3i) +#define glUniform3iv GLEW_GET_FUN(__glewUniform3iv) +#define glUniform4f GLEW_GET_FUN(__glewUniform4f) +#define glUniform4fv GLEW_GET_FUN(__glewUniform4fv) +#define glUniform4i GLEW_GET_FUN(__glewUniform4i) +#define glUniform4iv GLEW_GET_FUN(__glewUniform4iv) +#define glUniformMatrix2fv GLEW_GET_FUN(__glewUniformMatrix2fv) +#define glUniformMatrix3fv GLEW_GET_FUN(__glewUniformMatrix3fv) +#define glUniformMatrix4fv GLEW_GET_FUN(__glewUniformMatrix4fv) +#define glUseProgram GLEW_GET_FUN(__glewUseProgram) +#define glValidateProgram GLEW_GET_FUN(__glewValidateProgram) +#define glVertexAttrib1d GLEW_GET_FUN(__glewVertexAttrib1d) +#define glVertexAttrib1dv GLEW_GET_FUN(__glewVertexAttrib1dv) +#define glVertexAttrib1f GLEW_GET_FUN(__glewVertexAttrib1f) +#define glVertexAttrib1fv GLEW_GET_FUN(__glewVertexAttrib1fv) +#define glVertexAttrib1s GLEW_GET_FUN(__glewVertexAttrib1s) +#define glVertexAttrib1sv GLEW_GET_FUN(__glewVertexAttrib1sv) +#define glVertexAttrib2d GLEW_GET_FUN(__glewVertexAttrib2d) +#define glVertexAttrib2dv GLEW_GET_FUN(__glewVertexAttrib2dv) +#define glVertexAttrib2f GLEW_GET_FUN(__glewVertexAttrib2f) +#define glVertexAttrib2fv GLEW_GET_FUN(__glewVertexAttrib2fv) +#define glVertexAttrib2s GLEW_GET_FUN(__glewVertexAttrib2s) +#define glVertexAttrib2sv GLEW_GET_FUN(__glewVertexAttrib2sv) +#define glVertexAttrib3d GLEW_GET_FUN(__glewVertexAttrib3d) +#define glVertexAttrib3dv GLEW_GET_FUN(__glewVertexAttrib3dv) +#define glVertexAttrib3f GLEW_GET_FUN(__glewVertexAttrib3f) +#define glVertexAttrib3fv GLEW_GET_FUN(__glewVertexAttrib3fv) +#define glVertexAttrib3s GLEW_GET_FUN(__glewVertexAttrib3s) +#define glVertexAttrib3sv GLEW_GET_FUN(__glewVertexAttrib3sv) +#define glVertexAttrib4Nbv GLEW_GET_FUN(__glewVertexAttrib4Nbv) +#define glVertexAttrib4Niv GLEW_GET_FUN(__glewVertexAttrib4Niv) +#define glVertexAttrib4Nsv GLEW_GET_FUN(__glewVertexAttrib4Nsv) +#define glVertexAttrib4Nub GLEW_GET_FUN(__glewVertexAttrib4Nub) +#define glVertexAttrib4Nubv GLEW_GET_FUN(__glewVertexAttrib4Nubv) +#define glVertexAttrib4Nuiv GLEW_GET_FUN(__glewVertexAttrib4Nuiv) +#define glVertexAttrib4Nusv GLEW_GET_FUN(__glewVertexAttrib4Nusv) +#define glVertexAttrib4bv GLEW_GET_FUN(__glewVertexAttrib4bv) +#define glVertexAttrib4d GLEW_GET_FUN(__glewVertexAttrib4d) +#define glVertexAttrib4dv GLEW_GET_FUN(__glewVertexAttrib4dv) +#define glVertexAttrib4f GLEW_GET_FUN(__glewVertexAttrib4f) +#define glVertexAttrib4fv GLEW_GET_FUN(__glewVertexAttrib4fv) +#define glVertexAttrib4iv GLEW_GET_FUN(__glewVertexAttrib4iv) +#define glVertexAttrib4s GLEW_GET_FUN(__glewVertexAttrib4s) +#define glVertexAttrib4sv GLEW_GET_FUN(__glewVertexAttrib4sv) +#define glVertexAttrib4ubv GLEW_GET_FUN(__glewVertexAttrib4ubv) +#define glVertexAttrib4uiv GLEW_GET_FUN(__glewVertexAttrib4uiv) +#define glVertexAttrib4usv GLEW_GET_FUN(__glewVertexAttrib4usv) +#define glVertexAttribPointer GLEW_GET_FUN(__glewVertexAttribPointer) + +#define GLEW_VERSION_2_0 GLEW_GET_VAR(__GLEW_VERSION_2_0) + +#endif /* GL_VERSION_2_0 */ + +/* ----------------------------- GL_VERSION_2_1 ---------------------------- */ + +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 + +#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_SLUMINANCE_ALPHA 0x8C44 +#define GL_SLUMINANCE8_ALPHA8 0x8C45 +#define GL_SLUMINANCE 0x8C46 +#define GL_SLUMINANCE8 0x8C47 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPRESSED_SLUMINANCE 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B + +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + +#define glUniformMatrix2x3fv GLEW_GET_FUN(__glewUniformMatrix2x3fv) +#define glUniformMatrix2x4fv GLEW_GET_FUN(__glewUniformMatrix2x4fv) +#define glUniformMatrix3x2fv GLEW_GET_FUN(__glewUniformMatrix3x2fv) +#define glUniformMatrix3x4fv GLEW_GET_FUN(__glewUniformMatrix3x4fv) +#define glUniformMatrix4x2fv GLEW_GET_FUN(__glewUniformMatrix4x2fv) +#define glUniformMatrix4x3fv GLEW_GET_FUN(__glewUniformMatrix4x3fv) + +#define GLEW_VERSION_2_1 GLEW_GET_VAR(__GLEW_VERSION_2_1) + +#endif /* GL_VERSION_2_1 */ + +/* ----------------------------- GL_VERSION_3_0 ---------------------------- */ + +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 + +#define GL_MAX_CLIP_DISTANCES GL_MAX_CLIP_PLANES +#define GL_CLIP_DISTANCE5 GL_CLIP_PLANE5 +#define GL_CLIP_DISTANCE1 GL_CLIP_PLANE1 +#define GL_CLIP_DISTANCE3 GL_CLIP_PLANE3 +#define GL_COMPARE_REF_TO_TEXTURE GL_COMPARE_R_TO_TEXTURE_ARB +#define GL_CLIP_DISTANCE0 GL_CLIP_PLANE0 +#define GL_CLIP_DISTANCE4 GL_CLIP_PLANE4 +#define GL_CLIP_DISTANCE2 GL_CLIP_PLANE2 +#define GL_MAX_VARYING_COMPONENTS GL_MAX_VARYING_FLOATS +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_DEPTH_BUFFER 0x8223 +#define GL_STENCIL_BUFFER 0x8224 +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_VERTEX_COLOR 0x891A +#define GL_CLAMP_FRAGMENT_COLOR 0x891B +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE 0x8C15 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_ALPHA_INTEGER 0x8D97 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 + +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERPROC) (GLuint, GLenum); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum); +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint, GLuint, const GLchar*); +typedef void (GLAPIENTRY * PFNGLCLAMPCOLORPROC) (GLenum, GLenum); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFIPROC) (GLenum, GLint, GLfloat, GLint); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFVPROC) (GLenum, GLint, const GLfloat*); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERIVPROC) (GLenum, GLint, const GLint*); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERUIVPROC) (GLenum, GLint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLCOLORMASKIPROC) (GLuint, GLboolean, GLboolean, GLboolean, GLboolean); +typedef void (GLAPIENTRY * PFNGLDISABLEIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLENABLEIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERPROC) (void); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANI_VPROC) (GLenum, GLuint, GLboolean*); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint, const GLchar*); +typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVPROC) (GLenum, GLenum, GLint*); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVPROC) (GLenum, GLenum, GLuint*); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) (GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar *); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVPROC) (GLuint, GLint, GLuint*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVPROC) (GLuint, GLenum, GLint*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint, GLenum, GLuint*); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVPROC) (GLenum, GLenum, const GLint*); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVPROC) (GLenum, GLenum, const GLuint*); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint, GLsizei, const GLchar **, GLenum); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIPROC) (GLint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIPROC) (GLint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIPROC) (GLint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIPROC) (GLint, GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IPROC) (GLuint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIPROC) (GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IPROC) (GLuint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIPROC) (GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IPROC) (GLuint, GLint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIPROC) (GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVPROC) (GLuint, const GLbyte*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IPROC) (GLuint, GLint, GLint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVPROC) (GLuint, const GLshort*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVPROC) (GLuint, const GLubyte*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIPROC) (GLuint, GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVPROC) (GLuint, const GLushort*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint, GLint, GLenum, GLsizei, const GLvoid*); + +#define glBeginConditionalRender GLEW_GET_FUN(__glewBeginConditionalRender) +#define glBeginTransformFeedback GLEW_GET_FUN(__glewBeginTransformFeedback) +#define glBindFragDataLocation GLEW_GET_FUN(__glewBindFragDataLocation) +#define glClampColor GLEW_GET_FUN(__glewClampColor) +#define glClearBufferfi GLEW_GET_FUN(__glewClearBufferfi) +#define glClearBufferfv GLEW_GET_FUN(__glewClearBufferfv) +#define glClearBufferiv GLEW_GET_FUN(__glewClearBufferiv) +#define glClearBufferuiv GLEW_GET_FUN(__glewClearBufferuiv) +#define glColorMaski GLEW_GET_FUN(__glewColorMaski) +#define glDisablei GLEW_GET_FUN(__glewDisablei) +#define glEnablei GLEW_GET_FUN(__glewEnablei) +#define glEndConditionalRender GLEW_GET_FUN(__glewEndConditionalRender) +#define glEndTransformFeedback GLEW_GET_FUN(__glewEndTransformFeedback) +#define glGetBooleani_v GLEW_GET_FUN(__glewGetBooleani_v) +#define glGetFragDataLocation GLEW_GET_FUN(__glewGetFragDataLocation) +#define glGetStringi GLEW_GET_FUN(__glewGetStringi) +#define glGetTexParameterIiv GLEW_GET_FUN(__glewGetTexParameterIiv) +#define glGetTexParameterIuiv GLEW_GET_FUN(__glewGetTexParameterIuiv) +#define glGetTransformFeedbackVarying GLEW_GET_FUN(__glewGetTransformFeedbackVarying) +#define glGetUniformuiv GLEW_GET_FUN(__glewGetUniformuiv) +#define glGetVertexAttribIiv GLEW_GET_FUN(__glewGetVertexAttribIiv) +#define glGetVertexAttribIuiv GLEW_GET_FUN(__glewGetVertexAttribIuiv) +#define glIsEnabledi GLEW_GET_FUN(__glewIsEnabledi) +#define glTexParameterIiv GLEW_GET_FUN(__glewTexParameterIiv) +#define glTexParameterIuiv GLEW_GET_FUN(__glewTexParameterIuiv) +#define glTransformFeedbackVaryings GLEW_GET_FUN(__glewTransformFeedbackVaryings) +#define glUniform1ui GLEW_GET_FUN(__glewUniform1ui) +#define glUniform1uiv GLEW_GET_FUN(__glewUniform1uiv) +#define glUniform2ui GLEW_GET_FUN(__glewUniform2ui) +#define glUniform2uiv GLEW_GET_FUN(__glewUniform2uiv) +#define glUniform3ui GLEW_GET_FUN(__glewUniform3ui) +#define glUniform3uiv GLEW_GET_FUN(__glewUniform3uiv) +#define glUniform4ui GLEW_GET_FUN(__glewUniform4ui) +#define glUniform4uiv GLEW_GET_FUN(__glewUniform4uiv) +#define glVertexAttribI1i GLEW_GET_FUN(__glewVertexAttribI1i) +#define glVertexAttribI1iv GLEW_GET_FUN(__glewVertexAttribI1iv) +#define glVertexAttribI1ui GLEW_GET_FUN(__glewVertexAttribI1ui) +#define glVertexAttribI1uiv GLEW_GET_FUN(__glewVertexAttribI1uiv) +#define glVertexAttribI2i GLEW_GET_FUN(__glewVertexAttribI2i) +#define glVertexAttribI2iv GLEW_GET_FUN(__glewVertexAttribI2iv) +#define glVertexAttribI2ui GLEW_GET_FUN(__glewVertexAttribI2ui) +#define glVertexAttribI2uiv GLEW_GET_FUN(__glewVertexAttribI2uiv) +#define glVertexAttribI3i GLEW_GET_FUN(__glewVertexAttribI3i) +#define glVertexAttribI3iv GLEW_GET_FUN(__glewVertexAttribI3iv) +#define glVertexAttribI3ui GLEW_GET_FUN(__glewVertexAttribI3ui) +#define glVertexAttribI3uiv GLEW_GET_FUN(__glewVertexAttribI3uiv) +#define glVertexAttribI4bv GLEW_GET_FUN(__glewVertexAttribI4bv) +#define glVertexAttribI4i GLEW_GET_FUN(__glewVertexAttribI4i) +#define glVertexAttribI4iv GLEW_GET_FUN(__glewVertexAttribI4iv) +#define glVertexAttribI4sv GLEW_GET_FUN(__glewVertexAttribI4sv) +#define glVertexAttribI4ubv GLEW_GET_FUN(__glewVertexAttribI4ubv) +#define glVertexAttribI4ui GLEW_GET_FUN(__glewVertexAttribI4ui) +#define glVertexAttribI4uiv GLEW_GET_FUN(__glewVertexAttribI4uiv) +#define glVertexAttribI4usv GLEW_GET_FUN(__glewVertexAttribI4usv) +#define glVertexAttribIPointer GLEW_GET_FUN(__glewVertexAttribIPointer) + +#define GLEW_VERSION_3_0 GLEW_GET_VAR(__GLEW_VERSION_3_0) + +#endif /* GL_VERSION_3_0 */ + +/* ----------------------------- GL_VERSION_3_1 ---------------------------- */ + +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 + +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_BUFFER_FORMAT 0x8C2E +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_RED_SNORM 0x8F90 +#define GL_RG_SNORM 0x8F91 +#define GL_RGB_SNORM 0x8F92 +#define GL_RGBA_SNORM 0x8F93 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDPROC) (GLenum, GLint, GLsizei, GLsizei); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDPROC) (GLenum, GLsizei, GLenum, const GLvoid*, GLsizei); +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXPROC) (GLuint); +typedef void (GLAPIENTRY * PFNGLTEXBUFFERPROC) (GLenum, GLenum, GLuint); + +#define glDrawArraysInstanced GLEW_GET_FUN(__glewDrawArraysInstanced) +#define glDrawElementsInstanced GLEW_GET_FUN(__glewDrawElementsInstanced) +#define glPrimitiveRestartIndex GLEW_GET_FUN(__glewPrimitiveRestartIndex) +#define glTexBuffer GLEW_GET_FUN(__glewTexBuffer) + +#define GLEW_VERSION_3_1 GLEW_GET_VAR(__GLEW_VERSION_3_1) + +#endif /* GL_VERSION_3_1 */ + +/* ----------------------------- GL_VERSION_3_2 ---------------------------- */ + +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 + +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREPROC) (GLenum, GLenum, GLuint, GLint); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERI64VPROC) (GLenum, GLenum, GLint64 *); +typedef void (GLAPIENTRY * PFNGLGETINTEGER64I_VPROC) (GLenum, GLuint, GLint64 *); + +#define glFramebufferTexture GLEW_GET_FUN(__glewFramebufferTexture) +#define glGetBufferParameteri64v GLEW_GET_FUN(__glewGetBufferParameteri64v) +#define glGetInteger64i_v GLEW_GET_FUN(__glewGetInteger64i_v) + +#define GLEW_VERSION_3_2 GLEW_GET_VAR(__GLEW_VERSION_3_2) + +#endif /* GL_VERSION_3_2 */ + +/* ----------------------------- GL_VERSION_3_3 ---------------------------- */ + +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 + +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_RGB10_A2UI 0x906F + +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORPROC) (GLuint index, GLuint divisor); + +#define glVertexAttribDivisor GLEW_GET_FUN(__glewVertexAttribDivisor) + +#define GLEW_VERSION_3_3 GLEW_GET_VAR(__GLEW_VERSION_3_3) + +#endif /* GL_VERSION_3_3 */ + +/* ----------------------------- GL_VERSION_4_0 ---------------------------- */ + +#ifndef GL_VERSION_4_0 +#define GL_VERSION_4_0 1 + +#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F +#define GL_SAMPLE_SHADING 0x8C36 +#define GL_MIN_SAMPLE_SHADING_VALUE 0x8C37 +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A +#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B +#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C +#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D +#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E +#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F +#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS 0x8F9F +#define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A +#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY 0x900B +#define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIPROC) (GLuint buf, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCIPROC) (GLuint buf, GLenum src, GLenum dst); +typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGPROC) (GLclampf value); + +#define glBlendEquationSeparatei GLEW_GET_FUN(__glewBlendEquationSeparatei) +#define glBlendEquationi GLEW_GET_FUN(__glewBlendEquationi) +#define glBlendFuncSeparatei GLEW_GET_FUN(__glewBlendFuncSeparatei) +#define glBlendFunci GLEW_GET_FUN(__glewBlendFunci) +#define glMinSampleShading GLEW_GET_FUN(__glewMinSampleShading) + +#define GLEW_VERSION_4_0 GLEW_GET_VAR(__GLEW_VERSION_4_0) + +#endif /* GL_VERSION_4_0 */ + +/* ----------------------------- GL_VERSION_4_1 ---------------------------- */ + +#ifndef GL_VERSION_4_1 +#define GL_VERSION_4_1 1 + +#define GLEW_VERSION_4_1 GLEW_GET_VAR(__GLEW_VERSION_4_1) + +#endif /* GL_VERSION_4_1 */ + +/* ----------------------------- GL_VERSION_4_2 ---------------------------- */ + +#ifndef GL_VERSION_4_2 +#define GL_VERSION_4_2 1 + +#define GLEW_VERSION_4_2 GLEW_GET_VAR(__GLEW_VERSION_4_2) + +#endif /* GL_VERSION_4_2 */ + +/* -------------------------- GL_3DFX_multisample -------------------------- */ + +#ifndef GL_3DFX_multisample +#define GL_3DFX_multisample 1 + +#define GL_MULTISAMPLE_3DFX 0x86B2 +#define GL_SAMPLE_BUFFERS_3DFX 0x86B3 +#define GL_SAMPLES_3DFX 0x86B4 +#define GL_MULTISAMPLE_BIT_3DFX 0x20000000 + +#define GLEW_3DFX_multisample GLEW_GET_VAR(__GLEW_3DFX_multisample) + +#endif /* GL_3DFX_multisample */ + +/* ---------------------------- GL_3DFX_tbuffer ---------------------------- */ + +#ifndef GL_3DFX_tbuffer +#define GL_3DFX_tbuffer 1 + +typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); + +#define glTbufferMask3DFX GLEW_GET_FUN(__glewTbufferMask3DFX) + +#define GLEW_3DFX_tbuffer GLEW_GET_VAR(__GLEW_3DFX_tbuffer) + +#endif /* GL_3DFX_tbuffer */ + +/* -------------------- GL_3DFX_texture_compression_FXT1 ------------------- */ + +#ifndef GL_3DFX_texture_compression_FXT1 +#define GL_3DFX_texture_compression_FXT1 1 + +#define GL_COMPRESSED_RGB_FXT1_3DFX 0x86B0 +#define GL_COMPRESSED_RGBA_FXT1_3DFX 0x86B1 + +#define GLEW_3DFX_texture_compression_FXT1 GLEW_GET_VAR(__GLEW_3DFX_texture_compression_FXT1) + +#endif /* GL_3DFX_texture_compression_FXT1 */ + +/* ----------------------- GL_AMD_blend_minmax_factor ---------------------- */ + +#ifndef GL_AMD_blend_minmax_factor +#define GL_AMD_blend_minmax_factor 1 + +#define GL_FACTOR_MIN_AMD 0x901C +#define GL_FACTOR_MAX_AMD 0x901D + +#define GLEW_AMD_blend_minmax_factor GLEW_GET_VAR(__GLEW_AMD_blend_minmax_factor) + +#endif /* GL_AMD_blend_minmax_factor */ + +/* ----------------------- GL_AMD_conservative_depth ----------------------- */ + +#ifndef GL_AMD_conservative_depth +#define GL_AMD_conservative_depth 1 + +#define GLEW_AMD_conservative_depth GLEW_GET_VAR(__GLEW_AMD_conservative_depth) + +#endif /* GL_AMD_conservative_depth */ + +/* -------------------------- GL_AMD_debug_output -------------------------- */ + +#ifndef GL_AMD_debug_output +#define GL_AMD_debug_output 1 + +#define GL_MAX_DEBUG_MESSAGE_LENGTH_AMD 0x9143 +#define GL_MAX_DEBUG_LOGGED_MESSAGES_AMD 0x9144 +#define GL_DEBUG_LOGGED_MESSAGES_AMD 0x9145 +#define GL_DEBUG_SEVERITY_HIGH_AMD 0x9146 +#define GL_DEBUG_SEVERITY_MEDIUM_AMD 0x9147 +#define GL_DEBUG_SEVERITY_LOW_AMD 0x9148 +#define GL_DEBUG_CATEGORY_API_ERROR_AMD 0x9149 +#define GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD 0x914A +#define GL_DEBUG_CATEGORY_DEPRECATION_AMD 0x914B +#define GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD 0x914C +#define GL_DEBUG_CATEGORY_PERFORMANCE_AMD 0x914D +#define GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD 0x914E +#define GL_DEBUG_CATEGORY_APPLICATION_AMD 0x914F +#define GL_DEBUG_CATEGORY_OTHER_AMD 0x9150 + +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum severity, GLsizei length, const GLchar* message, GLvoid* userParam); + +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, void* userParam); +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const char* buf); +typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, char* message); + +#define glDebugMessageCallbackAMD GLEW_GET_FUN(__glewDebugMessageCallbackAMD) +#define glDebugMessageEnableAMD GLEW_GET_FUN(__glewDebugMessageEnableAMD) +#define glDebugMessageInsertAMD GLEW_GET_FUN(__glewDebugMessageInsertAMD) +#define glGetDebugMessageLogAMD GLEW_GET_FUN(__glewGetDebugMessageLogAMD) + +#define GLEW_AMD_debug_output GLEW_GET_VAR(__GLEW_AMD_debug_output) + +#endif /* GL_AMD_debug_output */ + +/* ---------------------- GL_AMD_depth_clamp_separate ---------------------- */ + +#ifndef GL_AMD_depth_clamp_separate +#define GL_AMD_depth_clamp_separate 1 + +#define GL_DEPTH_CLAMP_NEAR_AMD 0x901E +#define GL_DEPTH_CLAMP_FAR_AMD 0x901F + +#define GLEW_AMD_depth_clamp_separate GLEW_GET_VAR(__GLEW_AMD_depth_clamp_separate) + +#endif /* GL_AMD_depth_clamp_separate */ + +/* ----------------------- GL_AMD_draw_buffers_blend ----------------------- */ + +#ifndef GL_AMD_draw_buffers_blend +#define GL_AMD_draw_buffers_blend 1 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONINDEXEDAMDPROC) (GLuint buf, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCINDEXEDAMDPROC) (GLuint buf, GLenum src, GLenum dst); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); + +#define glBlendEquationIndexedAMD GLEW_GET_FUN(__glewBlendEquationIndexedAMD) +#define glBlendEquationSeparateIndexedAMD GLEW_GET_FUN(__glewBlendEquationSeparateIndexedAMD) +#define glBlendFuncIndexedAMD GLEW_GET_FUN(__glewBlendFuncIndexedAMD) +#define glBlendFuncSeparateIndexedAMD GLEW_GET_FUN(__glewBlendFuncSeparateIndexedAMD) + +#define GLEW_AMD_draw_buffers_blend GLEW_GET_VAR(__GLEW_AMD_draw_buffers_blend) + +#endif /* GL_AMD_draw_buffers_blend */ + +/* ----------------------- GL_AMD_multi_draw_indirect ---------------------- */ + +#ifndef GL_AMD_multi_draw_indirect +#define GL_AMD_multi_draw_indirect 1 + +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC) (GLenum mode, const void* indirect, GLsizei primcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC) (GLenum mode, GLenum type, const void* indirect, GLsizei primcount, GLsizei stride); + +#define glMultiDrawArraysIndirectAMD GLEW_GET_FUN(__glewMultiDrawArraysIndirectAMD) +#define glMultiDrawElementsIndirectAMD GLEW_GET_FUN(__glewMultiDrawElementsIndirectAMD) + +#define GLEW_AMD_multi_draw_indirect GLEW_GET_VAR(__GLEW_AMD_multi_draw_indirect) + +#endif /* GL_AMD_multi_draw_indirect */ + +/* ------------------------- GL_AMD_name_gen_delete ------------------------ */ + +#ifndef GL_AMD_name_gen_delete +#define GL_AMD_name_gen_delete 1 + +#define GL_DATA_BUFFER_AMD 0x9151 +#define GL_PERFORMANCE_MONITOR_AMD 0x9152 +#define GL_QUERY_OBJECT_AMD 0x9153 +#define GL_VERTEX_ARRAY_OBJECT_AMD 0x9154 +#define GL_SAMPLER_OBJECT_AMD 0x9155 + +typedef void (GLAPIENTRY * PFNGLDELETENAMESAMDPROC) (GLenum identifier, GLuint num, const GLuint* names); +typedef void (GLAPIENTRY * PFNGLGENNAMESAMDPROC) (GLenum identifier, GLuint num, GLuint* names); +typedef GLboolean (GLAPIENTRY * PFNGLISNAMEAMDPROC) (GLenum identifier, GLuint name); + +#define glDeleteNamesAMD GLEW_GET_FUN(__glewDeleteNamesAMD) +#define glGenNamesAMD GLEW_GET_FUN(__glewGenNamesAMD) +#define glIsNameAMD GLEW_GET_FUN(__glewIsNameAMD) + +#define GLEW_AMD_name_gen_delete GLEW_GET_VAR(__GLEW_AMD_name_gen_delete) + +#endif /* GL_AMD_name_gen_delete */ + +/* ----------------------- GL_AMD_performance_monitor ---------------------- */ + +#ifndef GL_AMD_performance_monitor +#define GL_AMD_performance_monitor 1 + +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_COUNTER_TYPE_AMD 0x8BC0 +#define GL_COUNTER_RANGE_AMD 0x8BC1 +#define GL_UNSIGNED_INT64_AMD 0x8BC2 +#define GL_PERCENTAGE_AMD 0x8BC3 +#define GL_PERFMON_RESULT_AVAILABLE_AMD 0x8BC4 +#define GL_PERFMON_RESULT_SIZE_AMD 0x8BC5 +#define GL_PERFMON_RESULT_AMD 0x8BC6 + +typedef void (GLAPIENTRY * PFNGLBEGINPERFMONITORAMDPROC) (GLuint monitor); +typedef void (GLAPIENTRY * PFNGLDELETEPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors); +typedef void (GLAPIENTRY * PFNGLENDPERFMONITORAMDPROC) (GLuint monitor); +typedef void (GLAPIENTRY * PFNGLGENPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERDATAAMDPROC) (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint *bytesWritten); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERINFOAMDPROC) (GLuint group, GLuint counter, GLenum pname, void* data); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC) (GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char *counterString); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSAMDPROC) (GLuint group, GLint* numCounters, GLint *maxActiveCounters, GLsizei countersSize, GLuint *counters); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSTRINGAMDPROC) (GLuint group, GLsizei bufSize, GLsizei* length, char *groupString); +typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSAMDPROC) (GLint* numGroups, GLsizei groupsSize, GLuint *groups); +typedef void (GLAPIENTRY * PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList); + +#define glBeginPerfMonitorAMD GLEW_GET_FUN(__glewBeginPerfMonitorAMD) +#define glDeletePerfMonitorsAMD GLEW_GET_FUN(__glewDeletePerfMonitorsAMD) +#define glEndPerfMonitorAMD GLEW_GET_FUN(__glewEndPerfMonitorAMD) +#define glGenPerfMonitorsAMD GLEW_GET_FUN(__glewGenPerfMonitorsAMD) +#define glGetPerfMonitorCounterDataAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterDataAMD) +#define glGetPerfMonitorCounterInfoAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterInfoAMD) +#define glGetPerfMonitorCounterStringAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterStringAMD) +#define glGetPerfMonitorCountersAMD GLEW_GET_FUN(__glewGetPerfMonitorCountersAMD) +#define glGetPerfMonitorGroupStringAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupStringAMD) +#define glGetPerfMonitorGroupsAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupsAMD) +#define glSelectPerfMonitorCountersAMD GLEW_GET_FUN(__glewSelectPerfMonitorCountersAMD) + +#define GLEW_AMD_performance_monitor GLEW_GET_VAR(__GLEW_AMD_performance_monitor) + +#endif /* GL_AMD_performance_monitor */ + +/* ------------------------ GL_AMD_sample_positions ------------------------ */ + +#ifndef GL_AMD_sample_positions +#define GL_AMD_sample_positions 1 + +#define GL_SUBSAMPLE_DISTANCE_AMD 0x883F + +typedef void (GLAPIENTRY * PFNGLSETMULTISAMPLEFVAMDPROC) (GLenum pname, GLuint index, const GLfloat* val); + +#define glSetMultisamplefvAMD GLEW_GET_FUN(__glewSetMultisamplefvAMD) + +#define GLEW_AMD_sample_positions GLEW_GET_VAR(__GLEW_AMD_sample_positions) + +#endif /* GL_AMD_sample_positions */ + +/* ------------------ GL_AMD_seamless_cubemap_per_texture ------------------ */ + +#ifndef GL_AMD_seamless_cubemap_per_texture +#define GL_AMD_seamless_cubemap_per_texture 1 + +#define GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB 0x884F + +#define GLEW_AMD_seamless_cubemap_per_texture GLEW_GET_VAR(__GLEW_AMD_seamless_cubemap_per_texture) + +#endif /* GL_AMD_seamless_cubemap_per_texture */ + +/* ---------------------- GL_AMD_shader_stencil_export --------------------- */ + +#ifndef GL_AMD_shader_stencil_export +#define GL_AMD_shader_stencil_export 1 + +#define GLEW_AMD_shader_stencil_export GLEW_GET_VAR(__GLEW_AMD_shader_stencil_export) + +#endif /* GL_AMD_shader_stencil_export */ + +/* ------------------------ GL_AMD_texture_texture4 ------------------------ */ + +#ifndef GL_AMD_texture_texture4 +#define GL_AMD_texture_texture4 1 + +#define GLEW_AMD_texture_texture4 GLEW_GET_VAR(__GLEW_AMD_texture_texture4) + +#endif /* GL_AMD_texture_texture4 */ + +/* --------------- GL_AMD_transform_feedback3_lines_triangles -------------- */ + +#ifndef GL_AMD_transform_feedback3_lines_triangles +#define GL_AMD_transform_feedback3_lines_triangles 1 + +#define GLEW_AMD_transform_feedback3_lines_triangles GLEW_GET_VAR(__GLEW_AMD_transform_feedback3_lines_triangles) + +#endif /* GL_AMD_transform_feedback3_lines_triangles */ + +/* -------------------- GL_AMD_vertex_shader_tessellator ------------------- */ + +#ifndef GL_AMD_vertex_shader_tessellator +#define GL_AMD_vertex_shader_tessellator 1 + +#define GL_SAMPLER_BUFFER_AMD 0x9001 +#define GL_INT_SAMPLER_BUFFER_AMD 0x9002 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD 0x9003 +#define GL_TESSELLATION_MODE_AMD 0x9004 +#define GL_TESSELLATION_FACTOR_AMD 0x9005 +#define GL_DISCRETE_AMD 0x9006 +#define GL_CONTINUOUS_AMD 0x9007 + +typedef void (GLAPIENTRY * PFNGLTESSELLATIONFACTORAMDPROC) (GLfloat factor); +typedef void (GLAPIENTRY * PFNGLTESSELLATIONMODEAMDPROC) (GLenum mode); + +#define glTessellationFactorAMD GLEW_GET_FUN(__glewTessellationFactorAMD) +#define glTessellationModeAMD GLEW_GET_FUN(__glewTessellationModeAMD) + +#define GLEW_AMD_vertex_shader_tessellator GLEW_GET_VAR(__GLEW_AMD_vertex_shader_tessellator) + +#endif /* GL_AMD_vertex_shader_tessellator */ + +/* ----------------------- GL_APPLE_aux_depth_stencil ---------------------- */ + +#ifndef GL_APPLE_aux_depth_stencil +#define GL_APPLE_aux_depth_stencil 1 + +#define GL_AUX_DEPTH_STENCIL_APPLE 0x8A14 + +#define GLEW_APPLE_aux_depth_stencil GLEW_GET_VAR(__GLEW_APPLE_aux_depth_stencil) + +#endif /* GL_APPLE_aux_depth_stencil */ + +/* ------------------------ GL_APPLE_client_storage ------------------------ */ + +#ifndef GL_APPLE_client_storage +#define GL_APPLE_client_storage 1 + +#define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2 + +#define GLEW_APPLE_client_storage GLEW_GET_VAR(__GLEW_APPLE_client_storage) + +#endif /* GL_APPLE_client_storage */ + +/* ------------------------- GL_APPLE_element_array ------------------------ */ + +#ifndef GL_APPLE_element_array +#define GL_APPLE_element_array 1 + +#define GL_ELEMENT_ARRAY_APPLE 0x8A0C +#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8A0D +#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x8A0E + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const void* pointer); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei *count, GLsizei primcount); + +#define glDrawElementArrayAPPLE GLEW_GET_FUN(__glewDrawElementArrayAPPLE) +#define glDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewDrawRangeElementArrayAPPLE) +#define glElementPointerAPPLE GLEW_GET_FUN(__glewElementPointerAPPLE) +#define glMultiDrawElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawElementArrayAPPLE) +#define glMultiDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawRangeElementArrayAPPLE) + +#define GLEW_APPLE_element_array GLEW_GET_VAR(__GLEW_APPLE_element_array) + +#endif /* GL_APPLE_element_array */ + +/* ----------------------------- GL_APPLE_fence ---------------------------- */ + +#ifndef GL_APPLE_fence +#define GL_APPLE_fence 1 + +#define GL_DRAW_PIXELS_APPLE 0x8A0A +#define GL_FENCE_APPLE 0x8A0B + +typedef void (GLAPIENTRY * PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint* fences); +typedef void (GLAPIENTRY * PFNGLFINISHFENCEAPPLEPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name); +typedef void (GLAPIENTRY * PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint* fences); +typedef GLboolean (GLAPIENTRY * PFNGLISFENCEAPPLEPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLSETFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (GLAPIENTRY * PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name); + +#define glDeleteFencesAPPLE GLEW_GET_FUN(__glewDeleteFencesAPPLE) +#define glFinishFenceAPPLE GLEW_GET_FUN(__glewFinishFenceAPPLE) +#define glFinishObjectAPPLE GLEW_GET_FUN(__glewFinishObjectAPPLE) +#define glGenFencesAPPLE GLEW_GET_FUN(__glewGenFencesAPPLE) +#define glIsFenceAPPLE GLEW_GET_FUN(__glewIsFenceAPPLE) +#define glSetFenceAPPLE GLEW_GET_FUN(__glewSetFenceAPPLE) +#define glTestFenceAPPLE GLEW_GET_FUN(__glewTestFenceAPPLE) +#define glTestObjectAPPLE GLEW_GET_FUN(__glewTestObjectAPPLE) + +#define GLEW_APPLE_fence GLEW_GET_VAR(__GLEW_APPLE_fence) + +#endif /* GL_APPLE_fence */ + +/* ------------------------- GL_APPLE_float_pixels ------------------------- */ + +#ifndef GL_APPLE_float_pixels +#define GL_APPLE_float_pixels 1 + +#define GL_HALF_APPLE 0x140B +#define GL_RGBA_FLOAT32_APPLE 0x8814 +#define GL_RGB_FLOAT32_APPLE 0x8815 +#define GL_ALPHA_FLOAT32_APPLE 0x8816 +#define GL_INTENSITY_FLOAT32_APPLE 0x8817 +#define GL_LUMINANCE_FLOAT32_APPLE 0x8818 +#define GL_LUMINANCE_ALPHA_FLOAT32_APPLE 0x8819 +#define GL_RGBA_FLOAT16_APPLE 0x881A +#define GL_RGB_FLOAT16_APPLE 0x881B +#define GL_ALPHA_FLOAT16_APPLE 0x881C +#define GL_INTENSITY_FLOAT16_APPLE 0x881D +#define GL_LUMINANCE_FLOAT16_APPLE 0x881E +#define GL_LUMINANCE_ALPHA_FLOAT16_APPLE 0x881F +#define GL_COLOR_FLOAT_APPLE 0x8A0F + +#define GLEW_APPLE_float_pixels GLEW_GET_VAR(__GLEW_APPLE_float_pixels) + +#endif /* GL_APPLE_float_pixels */ + +/* ---------------------- GL_APPLE_flush_buffer_range ---------------------- */ + +#ifndef GL_APPLE_flush_buffer_range +#define GL_APPLE_flush_buffer_range 1 + +#define GL_BUFFER_SERIALIZED_MODIFY_APPLE 0x8A12 +#define GL_BUFFER_FLUSHING_UNMAP_APPLE 0x8A13 + +typedef void (GLAPIENTRY * PFNGLBUFFERPARAMETERIAPPLEPROC) (GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target, GLintptr offset, GLsizeiptr size); + +#define glBufferParameteriAPPLE GLEW_GET_FUN(__glewBufferParameteriAPPLE) +#define glFlushMappedBufferRangeAPPLE GLEW_GET_FUN(__glewFlushMappedBufferRangeAPPLE) + +#define GLEW_APPLE_flush_buffer_range GLEW_GET_VAR(__GLEW_APPLE_flush_buffer_range) + +#endif /* GL_APPLE_flush_buffer_range */ + +/* ----------------------- GL_APPLE_object_purgeable ----------------------- */ + +#ifndef GL_APPLE_object_purgeable +#define GL_APPLE_object_purgeable 1 + +#define GL_BUFFER_OBJECT_APPLE 0x85B3 +#define GL_RELEASED_APPLE 0x8A19 +#define GL_VOLATILE_APPLE 0x8A1A +#define GL_RETAINED_APPLE 0x8A1B +#define GL_UNDEFINED_APPLE 0x8A1C +#define GL_PURGEABLE_APPLE 0x8A1D + +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVAPPLEPROC) (GLenum objectType, GLuint name, GLenum pname, GLint* params); +typedef GLenum (GLAPIENTRY * PFNGLOBJECTPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option); +typedef GLenum (GLAPIENTRY * PFNGLOBJECTUNPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option); + +#define glGetObjectParameterivAPPLE GLEW_GET_FUN(__glewGetObjectParameterivAPPLE) +#define glObjectPurgeableAPPLE GLEW_GET_FUN(__glewObjectPurgeableAPPLE) +#define glObjectUnpurgeableAPPLE GLEW_GET_FUN(__glewObjectUnpurgeableAPPLE) + +#define GLEW_APPLE_object_purgeable GLEW_GET_VAR(__GLEW_APPLE_object_purgeable) + +#endif /* GL_APPLE_object_purgeable */ + +/* ------------------------- GL_APPLE_pixel_buffer ------------------------- */ + +#ifndef GL_APPLE_pixel_buffer +#define GL_APPLE_pixel_buffer 1 + +#define GL_MIN_PBUFFER_VIEWPORT_DIMS_APPLE 0x8A10 + +#define GLEW_APPLE_pixel_buffer GLEW_GET_VAR(__GLEW_APPLE_pixel_buffer) + +#endif /* GL_APPLE_pixel_buffer */ + +/* ---------------------------- GL_APPLE_rgb_422 --------------------------- */ + +#ifndef GL_APPLE_rgb_422 +#define GL_APPLE_rgb_422 1 + +#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB +#define GL_RGB_422_APPLE 0x8A1F + +#define GLEW_APPLE_rgb_422 GLEW_GET_VAR(__GLEW_APPLE_rgb_422) + +#endif /* GL_APPLE_rgb_422 */ + +/* --------------------------- GL_APPLE_row_bytes -------------------------- */ + +#ifndef GL_APPLE_row_bytes +#define GL_APPLE_row_bytes 1 + +#define GL_PACK_ROW_BYTES_APPLE 0x8A15 +#define GL_UNPACK_ROW_BYTES_APPLE 0x8A16 + +#define GLEW_APPLE_row_bytes GLEW_GET_VAR(__GLEW_APPLE_row_bytes) + +#endif /* GL_APPLE_row_bytes */ + +/* ------------------------ GL_APPLE_specular_vector ----------------------- */ + +#ifndef GL_APPLE_specular_vector +#define GL_APPLE_specular_vector 1 + +#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0 + +#define GLEW_APPLE_specular_vector GLEW_GET_VAR(__GLEW_APPLE_specular_vector) + +#endif /* GL_APPLE_specular_vector */ + +/* ------------------------- GL_APPLE_texture_range ------------------------ */ + +#ifndef GL_APPLE_texture_range +#define GL_APPLE_texture_range 1 + +#define GL_TEXTURE_RANGE_LENGTH_APPLE 0x85B7 +#define GL_TEXTURE_RANGE_POINTER_APPLE 0x85B8 +#define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC +#define GL_STORAGE_PRIVATE_APPLE 0x85BD +#define GL_STORAGE_CACHED_APPLE 0x85BE +#define GL_STORAGE_SHARED_APPLE 0x85BF + +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC) (GLenum target, GLenum pname, GLvoid **params); +typedef void (GLAPIENTRY * PFNGLTEXTURERANGEAPPLEPROC) (GLenum target, GLsizei length, GLvoid *pointer); + +#define glGetTexParameterPointervAPPLE GLEW_GET_FUN(__glewGetTexParameterPointervAPPLE) +#define glTextureRangeAPPLE GLEW_GET_FUN(__glewTextureRangeAPPLE) + +#define GLEW_APPLE_texture_range GLEW_GET_VAR(__GLEW_APPLE_texture_range) + +#endif /* GL_APPLE_texture_range */ + +/* ------------------------ GL_APPLE_transform_hint ------------------------ */ + +#ifndef GL_APPLE_transform_hint +#define GL_APPLE_transform_hint 1 + +#define GL_TRANSFORM_HINT_APPLE 0x85B1 + +#define GLEW_APPLE_transform_hint GLEW_GET_VAR(__GLEW_APPLE_transform_hint) + +#endif /* GL_APPLE_transform_hint */ + +/* ---------------------- GL_APPLE_vertex_array_object --------------------- */ + +#ifndef GL_APPLE_vertex_array_object +#define GL_APPLE_vertex_array_object 1 + +#define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5 + +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array); + +#define glBindVertexArrayAPPLE GLEW_GET_FUN(__glewBindVertexArrayAPPLE) +#define glDeleteVertexArraysAPPLE GLEW_GET_FUN(__glewDeleteVertexArraysAPPLE) +#define glGenVertexArraysAPPLE GLEW_GET_FUN(__glewGenVertexArraysAPPLE) +#define glIsVertexArrayAPPLE GLEW_GET_FUN(__glewIsVertexArrayAPPLE) + +#define GLEW_APPLE_vertex_array_object GLEW_GET_VAR(__GLEW_APPLE_vertex_array_object) + +#endif /* GL_APPLE_vertex_array_object */ + +/* ---------------------- GL_APPLE_vertex_array_range ---------------------- */ + +#ifndef GL_APPLE_vertex_array_range +#define GL_APPLE_vertex_array_range 1 + +#define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E +#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F +#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_APPLE 0x8520 +#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521 +#define GL_STORAGE_CLIENT_APPLE 0x85B4 +#define GL_STORAGE_CACHED_APPLE 0x85BE +#define GL_STORAGE_SHARED_APPLE 0x85BF + +typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void* pointer); + +#define glFlushVertexArrayRangeAPPLE GLEW_GET_FUN(__glewFlushVertexArrayRangeAPPLE) +#define glVertexArrayParameteriAPPLE GLEW_GET_FUN(__glewVertexArrayParameteriAPPLE) +#define glVertexArrayRangeAPPLE GLEW_GET_FUN(__glewVertexArrayRangeAPPLE) + +#define GLEW_APPLE_vertex_array_range GLEW_GET_VAR(__GLEW_APPLE_vertex_array_range) + +#endif /* GL_APPLE_vertex_array_range */ + +/* ------------------- GL_APPLE_vertex_program_evaluators ------------------ */ + +#ifndef GL_APPLE_vertex_program_evaluators +#define GL_APPLE_vertex_program_evaluators 1 + +#define GL_VERTEX_ATTRIB_MAP1_APPLE 0x8A00 +#define GL_VERTEX_ATTRIB_MAP2_APPLE 0x8A01 +#define GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE 0x8A02 +#define GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE 0x8A03 +#define GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE 0x8A04 +#define GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE 0x8A05 +#define GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE 0x8A06 +#define GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE 0x8A07 +#define GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE 0x8A08 +#define GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE 0x8A09 + +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXATTRIBENABLEDAPPLEPROC) (GLuint index, GLenum pname); +typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); + +#define glDisableVertexAttribAPPLE GLEW_GET_FUN(__glewDisableVertexAttribAPPLE) +#define glEnableVertexAttribAPPLE GLEW_GET_FUN(__glewEnableVertexAttribAPPLE) +#define glIsVertexAttribEnabledAPPLE GLEW_GET_FUN(__glewIsVertexAttribEnabledAPPLE) +#define glMapVertexAttrib1dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1dAPPLE) +#define glMapVertexAttrib1fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1fAPPLE) +#define glMapVertexAttrib2dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2dAPPLE) +#define glMapVertexAttrib2fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2fAPPLE) + +#define GLEW_APPLE_vertex_program_evaluators GLEW_GET_VAR(__GLEW_APPLE_vertex_program_evaluators) + +#endif /* GL_APPLE_vertex_program_evaluators */ + +/* --------------------------- GL_APPLE_ycbcr_422 -------------------------- */ + +#ifndef GL_APPLE_ycbcr_422 +#define GL_APPLE_ycbcr_422 1 + +#define GL_YCBCR_422_APPLE 0x85B9 +#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB + +#define GLEW_APPLE_ycbcr_422 GLEW_GET_VAR(__GLEW_APPLE_ycbcr_422) + +#endif /* GL_APPLE_ycbcr_422 */ + +/* ------------------------ GL_ARB_ES2_compatibility ----------------------- */ + +#ifndef GL_ARB_ES2_compatibility +#define GL_ARB_ES2_compatibility 1 + +#define GL_FIXED 0x140C +#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B +#define GL_LOW_FLOAT 0x8DF0 +#define GL_MEDIUM_FLOAT 0x8DF1 +#define GL_HIGH_FLOAT 0x8DF2 +#define GL_LOW_INT 0x8DF3 +#define GL_MEDIUM_INT 0x8DF4 +#define GL_HIGH_INT 0x8DF5 +#define GL_SHADER_BINARY_FORMATS 0x8DF8 +#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9 +#define GL_SHADER_COMPILER 0x8DFA +#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB +#define GL_MAX_VARYING_VECTORS 0x8DFC +#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFPROC) (GLclampf d); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFPROC) (GLclampf n, GLclampf f); +typedef void (GLAPIENTRY * PFNGLGETSHADERPRECISIONFORMATPROC) (GLenum shadertype, GLenum precisiontype, GLint* range, GLint *precision); +typedef void (GLAPIENTRY * PFNGLRELEASESHADERCOMPILERPROC) (void); +typedef void (GLAPIENTRY * PFNGLSHADERBINARYPROC) (GLsizei count, const GLuint* shaders, GLenum binaryformat, const GLvoid*binary, GLsizei length); + +#define glClearDepthf GLEW_GET_FUN(__glewClearDepthf) +#define glDepthRangef GLEW_GET_FUN(__glewDepthRangef) +#define glGetShaderPrecisionFormat GLEW_GET_FUN(__glewGetShaderPrecisionFormat) +#define glReleaseShaderCompiler GLEW_GET_FUN(__glewReleaseShaderCompiler) +#define glShaderBinary GLEW_GET_FUN(__glewShaderBinary) + +#define GLEW_ARB_ES2_compatibility GLEW_GET_VAR(__GLEW_ARB_ES2_compatibility) + +#endif /* GL_ARB_ES2_compatibility */ + +/* -------------------------- GL_ARB_base_instance ------------------------- */ + +#ifndef GL_ARB_base_instance +#define GL_ARB_base_instance 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLuint baseinstance); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLint basevertex, GLuint baseinstance); + +#define glDrawArraysInstancedBaseInstance GLEW_GET_FUN(__glewDrawArraysInstancedBaseInstance) +#define glDrawElementsInstancedBaseInstance GLEW_GET_FUN(__glewDrawElementsInstancedBaseInstance) +#define glDrawElementsInstancedBaseVertexBaseInstance GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexBaseInstance) + +#define GLEW_ARB_base_instance GLEW_GET_VAR(__GLEW_ARB_base_instance) + +#endif /* GL_ARB_base_instance */ + +/* ----------------------- GL_ARB_blend_func_extended ---------------------- */ + +#ifndef GL_ARB_blend_func_extended +#define GL_ARB_blend_func_extended 1 + +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC + +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) (GLuint program, GLuint colorNumber, GLuint index, const char * name); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATAINDEXPROC) (GLuint program, const char * name); + +#define glBindFragDataLocationIndexed GLEW_GET_FUN(__glewBindFragDataLocationIndexed) +#define glGetFragDataIndex GLEW_GET_FUN(__glewGetFragDataIndex) + +#define GLEW_ARB_blend_func_extended GLEW_GET_VAR(__GLEW_ARB_blend_func_extended) + +#endif /* GL_ARB_blend_func_extended */ + +/* ---------------------------- GL_ARB_cl_event ---------------------------- */ + +#ifndef GL_ARB_cl_event +#define GL_ARB_cl_event 1 + +#define GL_SYNC_CL_EVENT_ARB 0x8240 +#define GL_SYNC_CL_EVENT_COMPLETE_ARB 0x8241 + +typedef struct _cl_context *cl_context; +typedef struct _cl_event *cl_event; + +typedef GLsync (GLAPIENTRY * PFNGLCREATESYNCFROMCLEVENTARBPROC) (cl_context context, cl_event event, GLbitfield flags); + +#define glCreateSyncFromCLeventARB GLEW_GET_FUN(__glewCreateSyncFromCLeventARB) + +#define GLEW_ARB_cl_event GLEW_GET_VAR(__GLEW_ARB_cl_event) + +#endif /* GL_ARB_cl_event */ + +/* ----------------------- GL_ARB_color_buffer_float ----------------------- */ + +#ifndef GL_ARB_color_buffer_float +#define GL_ARB_color_buffer_float 1 + +#define GL_RGBA_FLOAT_MODE_ARB 0x8820 +#define GL_CLAMP_VERTEX_COLOR_ARB 0x891A +#define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B +#define GL_CLAMP_READ_COLOR_ARB 0x891C +#define GL_FIXED_ONLY_ARB 0x891D + +typedef void (GLAPIENTRY * PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp); + +#define glClampColorARB GLEW_GET_FUN(__glewClampColorARB) + +#define GLEW_ARB_color_buffer_float GLEW_GET_VAR(__GLEW_ARB_color_buffer_float) + +#endif /* GL_ARB_color_buffer_float */ + +/* -------------------------- GL_ARB_compatibility ------------------------- */ + +#ifndef GL_ARB_compatibility +#define GL_ARB_compatibility 1 + +#define GLEW_ARB_compatibility GLEW_GET_VAR(__GLEW_ARB_compatibility) + +#endif /* GL_ARB_compatibility */ + +/* ---------------- GL_ARB_compressed_texture_pixel_storage ---------------- */ + +#ifndef GL_ARB_compressed_texture_pixel_storage +#define GL_ARB_compressed_texture_pixel_storage 1 + +#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127 +#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128 +#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129 +#define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A +#define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B +#define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C +#define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D +#define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E + +#define GLEW_ARB_compressed_texture_pixel_storage GLEW_GET_VAR(__GLEW_ARB_compressed_texture_pixel_storage) + +#endif /* GL_ARB_compressed_texture_pixel_storage */ + +/* ----------------------- GL_ARB_conservative_depth ----------------------- */ + +#ifndef GL_ARB_conservative_depth +#define GL_ARB_conservative_depth 1 + +#define GLEW_ARB_conservative_depth GLEW_GET_VAR(__GLEW_ARB_conservative_depth) + +#endif /* GL_ARB_conservative_depth */ + +/* --------------------------- GL_ARB_copy_buffer -------------------------- */ + +#ifndef GL_ARB_copy_buffer +#define GL_ARB_copy_buffer 1 + +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 + +typedef void (GLAPIENTRY * PFNGLCOPYBUFFERSUBDATAPROC) (GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size); + +#define glCopyBufferSubData GLEW_GET_FUN(__glewCopyBufferSubData) + +#define GLEW_ARB_copy_buffer GLEW_GET_VAR(__GLEW_ARB_copy_buffer) + +#endif /* GL_ARB_copy_buffer */ + +/* -------------------------- GL_ARB_debug_output -------------------------- */ + +#ifndef GL_ARB_debug_output +#define GL_ARB_debug_output 1 + +#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242 +#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243 +#define GL_DEBUG_CALLBACK_FUNCTION_ARB 0x8244 +#define GL_DEBUG_CALLBACK_USER_PARAM_ARB 0x8245 +#define GL_DEBUG_SOURCE_API_ARB 0x8246 +#define GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247 +#define GL_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248 +#define GL_DEBUG_SOURCE_THIRD_PARTY_ARB 0x8249 +#define GL_DEBUG_SOURCE_APPLICATION_ARB 0x824A +#define GL_DEBUG_SOURCE_OTHER_ARB 0x824B +#define GL_DEBUG_TYPE_ERROR_ARB 0x824C +#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D +#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E +#define GL_DEBUG_TYPE_PORTABILITY_ARB 0x824F +#define GL_DEBUG_TYPE_PERFORMANCE_ARB 0x8250 +#define GL_DEBUG_TYPE_OTHER_ARB 0x8251 +#define GL_MAX_DEBUG_MESSAGE_LENGTH_ARB 0x9143 +#define GL_MAX_DEBUG_LOGGED_MESSAGES_ARB 0x9144 +#define GL_DEBUG_LOGGED_MESSAGES_ARB 0x9145 +#define GL_DEBUG_SEVERITY_HIGH_ARB 0x9146 +#define GL_DEBUG_SEVERITY_MEDIUM_ARB 0x9147 +#define GL_DEBUG_SEVERITY_LOW_ARB 0x9148 + +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, GLvoid* userParam); + +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKARBPROC) (GLDEBUGPROCARB callback, void* userParam); +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECONTROLARBPROC) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); +typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTARBPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char* buf); +typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGARBPROC) (GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, char* messageLog); + +#define glDebugMessageCallbackARB GLEW_GET_FUN(__glewDebugMessageCallbackARB) +#define glDebugMessageControlARB GLEW_GET_FUN(__glewDebugMessageControlARB) +#define glDebugMessageInsertARB GLEW_GET_FUN(__glewDebugMessageInsertARB) +#define glGetDebugMessageLogARB GLEW_GET_FUN(__glewGetDebugMessageLogARB) + +#define GLEW_ARB_debug_output GLEW_GET_VAR(__GLEW_ARB_debug_output) + +#endif /* GL_ARB_debug_output */ + +/* ----------------------- GL_ARB_depth_buffer_float ----------------------- */ + +#ifndef GL_ARB_depth_buffer_float +#define GL_ARB_depth_buffer_float 1 + +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD + +#define GLEW_ARB_depth_buffer_float GLEW_GET_VAR(__GLEW_ARB_depth_buffer_float) + +#endif /* GL_ARB_depth_buffer_float */ + +/* --------------------------- GL_ARB_depth_clamp -------------------------- */ + +#ifndef GL_ARB_depth_clamp +#define GL_ARB_depth_clamp 1 + +#define GL_DEPTH_CLAMP 0x864F + +#define GLEW_ARB_depth_clamp GLEW_GET_VAR(__GLEW_ARB_depth_clamp) + +#endif /* GL_ARB_depth_clamp */ + +/* -------------------------- GL_ARB_depth_texture ------------------------- */ + +#ifndef GL_ARB_depth_texture +#define GL_ARB_depth_texture 1 + +#define GL_DEPTH_COMPONENT16_ARB 0x81A5 +#define GL_DEPTH_COMPONENT24_ARB 0x81A6 +#define GL_DEPTH_COMPONENT32_ARB 0x81A7 +#define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A +#define GL_DEPTH_TEXTURE_MODE_ARB 0x884B + +#define GLEW_ARB_depth_texture GLEW_GET_VAR(__GLEW_ARB_depth_texture) + +#endif /* GL_ARB_depth_texture */ + +/* -------------------------- GL_ARB_draw_buffers -------------------------- */ + +#ifndef GL_ARB_draw_buffers +#define GL_ARB_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_ARB 0x8824 +#define GL_DRAW_BUFFER0_ARB 0x8825 +#define GL_DRAW_BUFFER1_ARB 0x8826 +#define GL_DRAW_BUFFER2_ARB 0x8827 +#define GL_DRAW_BUFFER3_ARB 0x8828 +#define GL_DRAW_BUFFER4_ARB 0x8829 +#define GL_DRAW_BUFFER5_ARB 0x882A +#define GL_DRAW_BUFFER6_ARB 0x882B +#define GL_DRAW_BUFFER7_ARB 0x882C +#define GL_DRAW_BUFFER8_ARB 0x882D +#define GL_DRAW_BUFFER9_ARB 0x882E +#define GL_DRAW_BUFFER10_ARB 0x882F +#define GL_DRAW_BUFFER11_ARB 0x8830 +#define GL_DRAW_BUFFER12_ARB 0x8831 +#define GL_DRAW_BUFFER13_ARB 0x8832 +#define GL_DRAW_BUFFER14_ARB 0x8833 +#define GL_DRAW_BUFFER15_ARB 0x8834 + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersARB GLEW_GET_FUN(__glewDrawBuffersARB) + +#define GLEW_ARB_draw_buffers GLEW_GET_VAR(__GLEW_ARB_draw_buffers) + +#endif /* GL_ARB_draw_buffers */ + +/* ----------------------- GL_ARB_draw_buffers_blend ----------------------- */ + +#ifndef GL_ARB_draw_buffers_blend +#define GL_ARB_draw_buffers_blend 1 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIARBPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIARBPROC) (GLuint buf, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIARBPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCIARBPROC) (GLuint buf, GLenum src, GLenum dst); + +#define glBlendEquationSeparateiARB GLEW_GET_FUN(__glewBlendEquationSeparateiARB) +#define glBlendEquationiARB GLEW_GET_FUN(__glewBlendEquationiARB) +#define glBlendFuncSeparateiARB GLEW_GET_FUN(__glewBlendFuncSeparateiARB) +#define glBlendFunciARB GLEW_GET_FUN(__glewBlendFunciARB) + +#define GLEW_ARB_draw_buffers_blend GLEW_GET_VAR(__GLEW_ARB_draw_buffers_blend) + +#endif /* GL_ARB_draw_buffers_blend */ + +/* -------------------- GL_ARB_draw_elements_base_vertex ------------------- */ + +#ifndef GL_ARB_draw_elements_base_vertex +#define GL_ARB_draw_elements_base_vertex 1 + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, void* indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void* indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei* count, GLenum type, GLvoid**indices, GLsizei primcount, GLint *basevertex); + +#define glDrawElementsBaseVertex GLEW_GET_FUN(__glewDrawElementsBaseVertex) +#define glDrawElementsInstancedBaseVertex GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertex) +#define glDrawRangeElementsBaseVertex GLEW_GET_FUN(__glewDrawRangeElementsBaseVertex) +#define glMultiDrawElementsBaseVertex GLEW_GET_FUN(__glewMultiDrawElementsBaseVertex) + +#define GLEW_ARB_draw_elements_base_vertex GLEW_GET_VAR(__GLEW_ARB_draw_elements_base_vertex) + +#endif /* GL_ARB_draw_elements_base_vertex */ + +/* -------------------------- GL_ARB_draw_indirect ------------------------- */ + +#ifndef GL_ARB_draw_indirect +#define GL_ARB_draw_indirect 1 + +#define GL_DRAW_INDIRECT_BUFFER 0x8F3F +#define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINDIRECTPROC) (GLenum mode, const void* indirect); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINDIRECTPROC) (GLenum mode, GLenum type, const void* indirect); + +#define glDrawArraysIndirect GLEW_GET_FUN(__glewDrawArraysIndirect) +#define glDrawElementsIndirect GLEW_GET_FUN(__glewDrawElementsIndirect) + +#define GLEW_ARB_draw_indirect GLEW_GET_VAR(__GLEW_ARB_draw_indirect) + +#endif /* GL_ARB_draw_indirect */ + +/* ------------------------- GL_ARB_draw_instanced ------------------------- */ + +#ifndef GL_ARB_draw_instanced +#define GL_ARB_draw_instanced 1 + +#define GLEW_ARB_draw_instanced GLEW_GET_VAR(__GLEW_ARB_draw_instanced) + +#endif /* GL_ARB_draw_instanced */ + +/* -------------------- GL_ARB_explicit_attrib_location -------------------- */ + +#ifndef GL_ARB_explicit_attrib_location +#define GL_ARB_explicit_attrib_location 1 + +#define GLEW_ARB_explicit_attrib_location GLEW_GET_VAR(__GLEW_ARB_explicit_attrib_location) + +#endif /* GL_ARB_explicit_attrib_location */ + +/* ------------------- GL_ARB_fragment_coord_conventions ------------------- */ + +#ifndef GL_ARB_fragment_coord_conventions +#define GL_ARB_fragment_coord_conventions 1 + +#define GLEW_ARB_fragment_coord_conventions GLEW_GET_VAR(__GLEW_ARB_fragment_coord_conventions) + +#endif /* GL_ARB_fragment_coord_conventions */ + +/* ------------------------ GL_ARB_fragment_program ------------------------ */ + +#ifndef GL_ARB_fragment_program +#define GL_ARB_fragment_program 1 + +#define GL_FRAGMENT_PROGRAM_ARB 0x8804 +#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 +#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 +#define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 +#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 +#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 +#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A +#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B +#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C +#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D +#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E +#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F +#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 +#define GL_MAX_TEXTURE_COORDS_ARB 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 + +#define GLEW_ARB_fragment_program GLEW_GET_VAR(__GLEW_ARB_fragment_program) + +#endif /* GL_ARB_fragment_program */ + +/* --------------------- GL_ARB_fragment_program_shadow -------------------- */ + +#ifndef GL_ARB_fragment_program_shadow +#define GL_ARB_fragment_program_shadow 1 + +#define GLEW_ARB_fragment_program_shadow GLEW_GET_VAR(__GLEW_ARB_fragment_program_shadow) + +#endif /* GL_ARB_fragment_program_shadow */ + +/* ------------------------- GL_ARB_fragment_shader ------------------------ */ + +#ifndef GL_ARB_fragment_shader +#define GL_ARB_fragment_shader 1 + +#define GL_FRAGMENT_SHADER_ARB 0x8B30 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B + +#define GLEW_ARB_fragment_shader GLEW_GET_VAR(__GLEW_ARB_fragment_shader) + +#endif /* GL_ARB_fragment_shader */ + +/* ----------------------- GL_ARB_framebuffer_object ----------------------- */ + +#ifndef GL_ARB_framebuffer_object +#define GL_ARB_framebuffer_object 1 + +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_INDEX 0x8222 +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_SRGB 0x8C40 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 + +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFERPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFERPROC) (GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glBindFramebuffer GLEW_GET_FUN(__glewBindFramebuffer) +#define glBindRenderbuffer GLEW_GET_FUN(__glewBindRenderbuffer) +#define glBlitFramebuffer GLEW_GET_FUN(__glewBlitFramebuffer) +#define glCheckFramebufferStatus GLEW_GET_FUN(__glewCheckFramebufferStatus) +#define glDeleteFramebuffers GLEW_GET_FUN(__glewDeleteFramebuffers) +#define glDeleteRenderbuffers GLEW_GET_FUN(__glewDeleteRenderbuffers) +#define glFramebufferRenderbuffer GLEW_GET_FUN(__glewFramebufferRenderbuffer) +#define glFramebufferTexture1D GLEW_GET_FUN(__glewFramebufferTexture1D) +#define glFramebufferTexture2D GLEW_GET_FUN(__glewFramebufferTexture2D) +#define glFramebufferTexture3D GLEW_GET_FUN(__glewFramebufferTexture3D) +#define glFramebufferTextureLayer GLEW_GET_FUN(__glewFramebufferTextureLayer) +#define glGenFramebuffers GLEW_GET_FUN(__glewGenFramebuffers) +#define glGenRenderbuffers GLEW_GET_FUN(__glewGenRenderbuffers) +#define glGenerateMipmap GLEW_GET_FUN(__glewGenerateMipmap) +#define glGetFramebufferAttachmentParameteriv GLEW_GET_FUN(__glewGetFramebufferAttachmentParameteriv) +#define glGetRenderbufferParameteriv GLEW_GET_FUN(__glewGetRenderbufferParameteriv) +#define glIsFramebuffer GLEW_GET_FUN(__glewIsFramebuffer) +#define glIsRenderbuffer GLEW_GET_FUN(__glewIsRenderbuffer) +#define glRenderbufferStorage GLEW_GET_FUN(__glewRenderbufferStorage) +#define glRenderbufferStorageMultisample GLEW_GET_FUN(__glewRenderbufferStorageMultisample) + +#define GLEW_ARB_framebuffer_object GLEW_GET_VAR(__GLEW_ARB_framebuffer_object) + +#endif /* GL_ARB_framebuffer_object */ + +/* ------------------------ GL_ARB_framebuffer_sRGB ------------------------ */ + +#ifndef GL_ARB_framebuffer_sRGB +#define GL_ARB_framebuffer_sRGB 1 + +#define GL_FRAMEBUFFER_SRGB 0x8DB9 + +#define GLEW_ARB_framebuffer_sRGB GLEW_GET_VAR(__GLEW_ARB_framebuffer_sRGB) + +#endif /* GL_ARB_framebuffer_sRGB */ + +/* ------------------------ GL_ARB_geometry_shader4 ------------------------ */ + +#ifndef GL_ARB_geometry_shader4 +#define GL_ARB_geometry_shader4 1 + +#define GL_LINES_ADJACENCY_ARB 0xA +#define GL_LINE_STRIP_ADJACENCY_ARB 0xB +#define GL_TRIANGLES_ADJACENCY_ARB 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_ARB 0xD +#define GL_PROGRAM_POINT_SIZE_ARB 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB 0x8DA8 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB 0x8DA9 +#define GL_GEOMETRY_SHADER_ARB 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT_ARB 0x8DDA +#define GL_GEOMETRY_INPUT_TYPE_ARB 0x8DDB +#define GL_GEOMETRY_OUTPUT_TYPE_ARB 0x8DDC +#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB 0x8DDD +#define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB 0x8DDE +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB 0x8DE1 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenum pname, GLint value); + +#define glFramebufferTextureARB GLEW_GET_FUN(__glewFramebufferTextureARB) +#define glFramebufferTextureFaceARB GLEW_GET_FUN(__glewFramebufferTextureFaceARB) +#define glFramebufferTextureLayerARB GLEW_GET_FUN(__glewFramebufferTextureLayerARB) +#define glProgramParameteriARB GLEW_GET_FUN(__glewProgramParameteriARB) + +#define GLEW_ARB_geometry_shader4 GLEW_GET_VAR(__GLEW_ARB_geometry_shader4) + +#endif /* GL_ARB_geometry_shader4 */ + +/* ----------------------- GL_ARB_get_program_binary ----------------------- */ + +#ifndef GL_ARB_get_program_binary +#define GL_ARB_get_program_binary 1 + +#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257 +#define GL_PROGRAM_BINARY_LENGTH 0x8741 +#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE +#define GL_PROGRAM_BINARY_FORMATS 0x87FF + +typedef void (GLAPIENTRY * PFNGLGETPROGRAMBINARYPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLenum *binaryFormat, GLvoid*binary); +typedef void (GLAPIENTRY * PFNGLPROGRAMBINARYPROC) (GLuint program, GLenum binaryFormat, const void* binary, GLsizei length); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIPROC) (GLuint program, GLenum pname, GLint value); + +#define glGetProgramBinary GLEW_GET_FUN(__glewGetProgramBinary) +#define glProgramBinary GLEW_GET_FUN(__glewProgramBinary) +#define glProgramParameteri GLEW_GET_FUN(__glewProgramParameteri) + +#define GLEW_ARB_get_program_binary GLEW_GET_VAR(__GLEW_ARB_get_program_binary) + +#endif /* GL_ARB_get_program_binary */ + +/* --------------------------- GL_ARB_gpu_shader5 -------------------------- */ + +#ifndef GL_ARB_gpu_shader5 +#define GL_ARB_gpu_shader5 1 + +#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A +#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B +#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C +#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D +#define GL_MAX_VERTEX_STREAMS 0x8E71 + +#define GLEW_ARB_gpu_shader5 GLEW_GET_VAR(__GLEW_ARB_gpu_shader5) + +#endif /* GL_ARB_gpu_shader5 */ + +/* ------------------------- GL_ARB_gpu_shader_fp64 ------------------------ */ + +#ifndef GL_ARB_gpu_shader_fp64 +#define GL_ARB_gpu_shader_fp64 1 + +#define GL_DOUBLE_MAT2 0x8F46 +#define GL_DOUBLE_MAT3 0x8F47 +#define GL_DOUBLE_MAT4 0x8F48 +#define GL_DOUBLE_MAT2x3 0x8F49 +#define GL_DOUBLE_MAT2x4 0x8F4A +#define GL_DOUBLE_MAT3x2 0x8F4B +#define GL_DOUBLE_MAT3x4 0x8F4C +#define GL_DOUBLE_MAT4x2 0x8F4D +#define GL_DOUBLE_MAT4x3 0x8F4E +#define GL_DOUBLE_VEC2 0x8FFC +#define GL_DOUBLE_VEC3 0x8FFD +#define GL_DOUBLE_VEC4 0x8FFE + +typedef void (GLAPIENTRY * PFNGLGETUNIFORMDVPROC) (GLuint program, GLint location, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DEXTPROC) (GLuint program, GLint location, GLdouble x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1DPROC) (GLint location, GLdouble x); +typedef void (GLAPIENTRY * PFNGLUNIFORM1DVPROC) (GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2DPROC) (GLint location, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLUNIFORM2DVPROC) (GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLUNIFORM3DVPROC) (GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLUNIFORM4DVPROC) (GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); + +#define glGetUniformdv GLEW_GET_FUN(__glewGetUniformdv) +#define glProgramUniform1dEXT GLEW_GET_FUN(__glewProgramUniform1dEXT) +#define glProgramUniform1dvEXT GLEW_GET_FUN(__glewProgramUniform1dvEXT) +#define glProgramUniform2dEXT GLEW_GET_FUN(__glewProgramUniform2dEXT) +#define glProgramUniform2dvEXT GLEW_GET_FUN(__glewProgramUniform2dvEXT) +#define glProgramUniform3dEXT GLEW_GET_FUN(__glewProgramUniform3dEXT) +#define glProgramUniform3dvEXT GLEW_GET_FUN(__glewProgramUniform3dvEXT) +#define glProgramUniform4dEXT GLEW_GET_FUN(__glewProgramUniform4dEXT) +#define glProgramUniform4dvEXT GLEW_GET_FUN(__glewProgramUniform4dvEXT) +#define glProgramUniformMatrix2dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2dvEXT) +#define glProgramUniformMatrix2x3dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x3dvEXT) +#define glProgramUniformMatrix2x4dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x4dvEXT) +#define glProgramUniformMatrix3dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3dvEXT) +#define glProgramUniformMatrix3x2dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x2dvEXT) +#define glProgramUniformMatrix3x4dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x4dvEXT) +#define glProgramUniformMatrix4dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4dvEXT) +#define glProgramUniformMatrix4x2dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x2dvEXT) +#define glProgramUniformMatrix4x3dvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x3dvEXT) +#define glUniform1d GLEW_GET_FUN(__glewUniform1d) +#define glUniform1dv GLEW_GET_FUN(__glewUniform1dv) +#define glUniform2d GLEW_GET_FUN(__glewUniform2d) +#define glUniform2dv GLEW_GET_FUN(__glewUniform2dv) +#define glUniform3d GLEW_GET_FUN(__glewUniform3d) +#define glUniform3dv GLEW_GET_FUN(__glewUniform3dv) +#define glUniform4d GLEW_GET_FUN(__glewUniform4d) +#define glUniform4dv GLEW_GET_FUN(__glewUniform4dv) +#define glUniformMatrix2dv GLEW_GET_FUN(__glewUniformMatrix2dv) +#define glUniformMatrix2x3dv GLEW_GET_FUN(__glewUniformMatrix2x3dv) +#define glUniformMatrix2x4dv GLEW_GET_FUN(__glewUniformMatrix2x4dv) +#define glUniformMatrix3dv GLEW_GET_FUN(__glewUniformMatrix3dv) +#define glUniformMatrix3x2dv GLEW_GET_FUN(__glewUniformMatrix3x2dv) +#define glUniformMatrix3x4dv GLEW_GET_FUN(__glewUniformMatrix3x4dv) +#define glUniformMatrix4dv GLEW_GET_FUN(__glewUniformMatrix4dv) +#define glUniformMatrix4x2dv GLEW_GET_FUN(__glewUniformMatrix4x2dv) +#define glUniformMatrix4x3dv GLEW_GET_FUN(__glewUniformMatrix4x3dv) + +#define GLEW_ARB_gpu_shader_fp64 GLEW_GET_VAR(__GLEW_ARB_gpu_shader_fp64) + +#endif /* GL_ARB_gpu_shader_fp64 */ + +/* ------------------------ GL_ARB_half_float_pixel ------------------------ */ + +#ifndef GL_ARB_half_float_pixel +#define GL_ARB_half_float_pixel 1 + +#define GL_HALF_FLOAT_ARB 0x140B + +#define GLEW_ARB_half_float_pixel GLEW_GET_VAR(__GLEW_ARB_half_float_pixel) + +#endif /* GL_ARB_half_float_pixel */ + +/* ------------------------ GL_ARB_half_float_vertex ----------------------- */ + +#ifndef GL_ARB_half_float_vertex +#define GL_ARB_half_float_vertex 1 + +#define GL_HALF_FLOAT 0x140B + +#define GLEW_ARB_half_float_vertex GLEW_GET_VAR(__GLEW_ARB_half_float_vertex) + +#endif /* GL_ARB_half_float_vertex */ + +/* ----------------------------- GL_ARB_imaging ---------------------------- */ + +#ifndef GL_ARB_imaging +#define GL_ARB_imaging 1 + +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_BLEND_COLOR 0x8005 +#define GL_FUNC_ADD 0x8006 +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BLEND_EQUATION 0x8009 +#define GL_FUNC_SUBTRACT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_CONVOLUTION_1D 0x8010 +#define GL_CONVOLUTION_2D 0x8011 +#define GL_SEPARABLE_2D 0x8012 +#define GL_CONVOLUTION_BORDER_MODE 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS 0x8015 +#define GL_REDUCE 0x8016 +#define GL_CONVOLUTION_FORMAT 0x8017 +#define GL_CONVOLUTION_WIDTH 0x8018 +#define GL_CONVOLUTION_HEIGHT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 +#define GL_HISTOGRAM 0x8024 +#define GL_PROXY_HISTOGRAM 0x8025 +#define GL_HISTOGRAM_WIDTH 0x8026 +#define GL_HISTOGRAM_FORMAT 0x8027 +#define GL_HISTOGRAM_RED_SIZE 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C +#define GL_HISTOGRAM_SINK 0x802D +#define GL_MINMAX 0x802E +#define GL_MINMAX_FORMAT 0x802F +#define GL_MINMAX_SINK 0x8030 +#define GL_TABLE_TOO_LARGE 0x8031 +#define GL_COLOR_MATRIX 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB +#define GL_COLOR_TABLE 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 +#define GL_PROXY_COLOR_TABLE 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 +#define GL_COLOR_TABLE_SCALE 0x80D6 +#define GL_COLOR_TABLE_BIAS 0x80D7 +#define GL_COLOR_TABLE_FORMAT 0x80D8 +#define GL_COLOR_TABLE_WIDTH 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF +#define GL_IGNORE_BORDER 0x8150 +#define GL_CONSTANT_BORDER 0x8151 +#define GL_WRAP_BORDER 0x8152 +#define GL_REPLICATE_BORDER 0x8153 +#define GL_CONVOLUTION_BORDER_COLOR 0x8154 + +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); +typedef void (GLAPIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLRESETMINMAXPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); + +#define glColorSubTable GLEW_GET_FUN(__glewColorSubTable) +#define glColorTable GLEW_GET_FUN(__glewColorTable) +#define glColorTableParameterfv GLEW_GET_FUN(__glewColorTableParameterfv) +#define glColorTableParameteriv GLEW_GET_FUN(__glewColorTableParameteriv) +#define glConvolutionFilter1D GLEW_GET_FUN(__glewConvolutionFilter1D) +#define glConvolutionFilter2D GLEW_GET_FUN(__glewConvolutionFilter2D) +#define glConvolutionParameterf GLEW_GET_FUN(__glewConvolutionParameterf) +#define glConvolutionParameterfv GLEW_GET_FUN(__glewConvolutionParameterfv) +#define glConvolutionParameteri GLEW_GET_FUN(__glewConvolutionParameteri) +#define glConvolutionParameteriv GLEW_GET_FUN(__glewConvolutionParameteriv) +#define glCopyColorSubTable GLEW_GET_FUN(__glewCopyColorSubTable) +#define glCopyColorTable GLEW_GET_FUN(__glewCopyColorTable) +#define glCopyConvolutionFilter1D GLEW_GET_FUN(__glewCopyConvolutionFilter1D) +#define glCopyConvolutionFilter2D GLEW_GET_FUN(__glewCopyConvolutionFilter2D) +#define glGetColorTable GLEW_GET_FUN(__glewGetColorTable) +#define glGetColorTableParameterfv GLEW_GET_FUN(__glewGetColorTableParameterfv) +#define glGetColorTableParameteriv GLEW_GET_FUN(__glewGetColorTableParameteriv) +#define glGetConvolutionFilter GLEW_GET_FUN(__glewGetConvolutionFilter) +#define glGetConvolutionParameterfv GLEW_GET_FUN(__glewGetConvolutionParameterfv) +#define glGetConvolutionParameteriv GLEW_GET_FUN(__glewGetConvolutionParameteriv) +#define glGetHistogram GLEW_GET_FUN(__glewGetHistogram) +#define glGetHistogramParameterfv GLEW_GET_FUN(__glewGetHistogramParameterfv) +#define glGetHistogramParameteriv GLEW_GET_FUN(__glewGetHistogramParameteriv) +#define glGetMinmax GLEW_GET_FUN(__glewGetMinmax) +#define glGetMinmaxParameterfv GLEW_GET_FUN(__glewGetMinmaxParameterfv) +#define glGetMinmaxParameteriv GLEW_GET_FUN(__glewGetMinmaxParameteriv) +#define glGetSeparableFilter GLEW_GET_FUN(__glewGetSeparableFilter) +#define glHistogram GLEW_GET_FUN(__glewHistogram) +#define glMinmax GLEW_GET_FUN(__glewMinmax) +#define glResetHistogram GLEW_GET_FUN(__glewResetHistogram) +#define glResetMinmax GLEW_GET_FUN(__glewResetMinmax) +#define glSeparableFilter2D GLEW_GET_FUN(__glewSeparableFilter2D) + +#define GLEW_ARB_imaging GLEW_GET_VAR(__GLEW_ARB_imaging) + +#endif /* GL_ARB_imaging */ + +/* ------------------------ GL_ARB_instanced_arrays ------------------------ */ + +#ifndef GL_ARB_instanced_arrays +#define GL_ARB_instanced_arrays 1 + +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB 0x88FE + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORARBPROC) (GLuint index, GLuint divisor); + +#define glDrawArraysInstancedARB GLEW_GET_FUN(__glewDrawArraysInstancedARB) +#define glDrawElementsInstancedARB GLEW_GET_FUN(__glewDrawElementsInstancedARB) +#define glVertexAttribDivisorARB GLEW_GET_FUN(__glewVertexAttribDivisorARB) + +#define GLEW_ARB_instanced_arrays GLEW_GET_VAR(__GLEW_ARB_instanced_arrays) + +#endif /* GL_ARB_instanced_arrays */ + +/* ---------------------- GL_ARB_internalformat_query ---------------------- */ + +#ifndef GL_ARB_internalformat_query +#define GL_ARB_internalformat_query 1 + +#define GL_NUM_SAMPLE_COUNTS 0x9380 + +typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATIVPROC) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params); + +#define glGetInternalformativ GLEW_GET_FUN(__glewGetInternalformativ) + +#define GLEW_ARB_internalformat_query GLEW_GET_VAR(__GLEW_ARB_internalformat_query) + +#endif /* GL_ARB_internalformat_query */ + +/* ---------------------- GL_ARB_map_buffer_alignment ---------------------- */ + +#ifndef GL_ARB_map_buffer_alignment +#define GL_ARB_map_buffer_alignment 1 + +#define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC + +#define GLEW_ARB_map_buffer_alignment GLEW_GET_VAR(__GLEW_ARB_map_buffer_alignment) + +#endif /* GL_ARB_map_buffer_alignment */ + +/* ------------------------ GL_ARB_map_buffer_range ------------------------ */ + +#ifndef GL_ARB_map_buffer_range +#define GL_ARB_map_buffer_range 1 + +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 + +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + +#define glFlushMappedBufferRange GLEW_GET_FUN(__glewFlushMappedBufferRange) +#define glMapBufferRange GLEW_GET_FUN(__glewMapBufferRange) + +#define GLEW_ARB_map_buffer_range GLEW_GET_VAR(__GLEW_ARB_map_buffer_range) + +#endif /* GL_ARB_map_buffer_range */ + +/* ------------------------- GL_ARB_matrix_palette ------------------------- */ + +#ifndef GL_ARB_matrix_palette +#define GL_ARB_matrix_palette 1 + +#define GL_MATRIX_PALETTE_ARB 0x8840 +#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 +#define GL_MAX_PALETTE_MATRICES_ARB 0x8842 +#define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843 +#define GL_MATRIX_INDEX_ARRAY_ARB 0x8844 +#define GL_CURRENT_MATRIX_INDEX_ARB 0x8845 +#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 +#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 +#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 +#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 + +typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUBVARBPROC) (GLint size, GLubyte *indices); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUIVARBPROC) (GLint size, GLuint *indices); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUSVARBPROC) (GLint size, GLushort *indices); + +#define glCurrentPaletteMatrixARB GLEW_GET_FUN(__glewCurrentPaletteMatrixARB) +#define glMatrixIndexPointerARB GLEW_GET_FUN(__glewMatrixIndexPointerARB) +#define glMatrixIndexubvARB GLEW_GET_FUN(__glewMatrixIndexubvARB) +#define glMatrixIndexuivARB GLEW_GET_FUN(__glewMatrixIndexuivARB) +#define glMatrixIndexusvARB GLEW_GET_FUN(__glewMatrixIndexusvARB) + +#define GLEW_ARB_matrix_palette GLEW_GET_VAR(__GLEW_ARB_matrix_palette) + +#endif /* GL_ARB_matrix_palette */ + +/* --------------------------- GL_ARB_multisample -------------------------- */ + +#ifndef GL_ARB_multisample +#define GL_ARB_multisample 1 + +#define GL_MULTISAMPLE_ARB 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F +#define GL_SAMPLE_COVERAGE_ARB 0x80A0 +#define GL_SAMPLE_BUFFERS_ARB 0x80A8 +#define GL_SAMPLES_ARB 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB +#define GL_MULTISAMPLE_BIT_ARB 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert); + +#define glSampleCoverageARB GLEW_GET_FUN(__glewSampleCoverageARB) + +#define GLEW_ARB_multisample GLEW_GET_VAR(__GLEW_ARB_multisample) + +#endif /* GL_ARB_multisample */ + +/* -------------------------- GL_ARB_multitexture -------------------------- */ + +#ifndef GL_ARB_multitexture +#define GL_ARB_multitexture 1 + +#define GL_TEXTURE0_ARB 0x84C0 +#define GL_TEXTURE1_ARB 0x84C1 +#define GL_TEXTURE2_ARB 0x84C2 +#define GL_TEXTURE3_ARB 0x84C3 +#define GL_TEXTURE4_ARB 0x84C4 +#define GL_TEXTURE5_ARB 0x84C5 +#define GL_TEXTURE6_ARB 0x84C6 +#define GL_TEXTURE7_ARB 0x84C7 +#define GL_TEXTURE8_ARB 0x84C8 +#define GL_TEXTURE9_ARB 0x84C9 +#define GL_TEXTURE10_ARB 0x84CA +#define GL_TEXTURE11_ARB 0x84CB +#define GL_TEXTURE12_ARB 0x84CC +#define GL_TEXTURE13_ARB 0x84CD +#define GL_TEXTURE14_ARB 0x84CE +#define GL_TEXTURE15_ARB 0x84CF +#define GL_TEXTURE16_ARB 0x84D0 +#define GL_TEXTURE17_ARB 0x84D1 +#define GL_TEXTURE18_ARB 0x84D2 +#define GL_TEXTURE19_ARB 0x84D3 +#define GL_TEXTURE20_ARB 0x84D4 +#define GL_TEXTURE21_ARB 0x84D5 +#define GL_TEXTURE22_ARB 0x84D6 +#define GL_TEXTURE23_ARB 0x84D7 +#define GL_TEXTURE24_ARB 0x84D8 +#define GL_TEXTURE25_ARB 0x84D9 +#define GL_TEXTURE26_ARB 0x84DA +#define GL_TEXTURE27_ARB 0x84DB +#define GL_TEXTURE28_ARB 0x84DC +#define GL_TEXTURE29_ARB 0x84DD +#define GL_TEXTURE30_ARB 0x84DE +#define GL_TEXTURE31_ARB 0x84DF +#define GL_ACTIVE_TEXTURE_ARB 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 +#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 + +typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); + +#define glActiveTextureARB GLEW_GET_FUN(__glewActiveTextureARB) +#define glClientActiveTextureARB GLEW_GET_FUN(__glewClientActiveTextureARB) +#define glMultiTexCoord1dARB GLEW_GET_FUN(__glewMultiTexCoord1dARB) +#define glMultiTexCoord1dvARB GLEW_GET_FUN(__glewMultiTexCoord1dvARB) +#define glMultiTexCoord1fARB GLEW_GET_FUN(__glewMultiTexCoord1fARB) +#define glMultiTexCoord1fvARB GLEW_GET_FUN(__glewMultiTexCoord1fvARB) +#define glMultiTexCoord1iARB GLEW_GET_FUN(__glewMultiTexCoord1iARB) +#define glMultiTexCoord1ivARB GLEW_GET_FUN(__glewMultiTexCoord1ivARB) +#define glMultiTexCoord1sARB GLEW_GET_FUN(__glewMultiTexCoord1sARB) +#define glMultiTexCoord1svARB GLEW_GET_FUN(__glewMultiTexCoord1svARB) +#define glMultiTexCoord2dARB GLEW_GET_FUN(__glewMultiTexCoord2dARB) +#define glMultiTexCoord2dvARB GLEW_GET_FUN(__glewMultiTexCoord2dvARB) +#define glMultiTexCoord2fARB GLEW_GET_FUN(__glewMultiTexCoord2fARB) +#define glMultiTexCoord2fvARB GLEW_GET_FUN(__glewMultiTexCoord2fvARB) +#define glMultiTexCoord2iARB GLEW_GET_FUN(__glewMultiTexCoord2iARB) +#define glMultiTexCoord2ivARB GLEW_GET_FUN(__glewMultiTexCoord2ivARB) +#define glMultiTexCoord2sARB GLEW_GET_FUN(__glewMultiTexCoord2sARB) +#define glMultiTexCoord2svARB GLEW_GET_FUN(__glewMultiTexCoord2svARB) +#define glMultiTexCoord3dARB GLEW_GET_FUN(__glewMultiTexCoord3dARB) +#define glMultiTexCoord3dvARB GLEW_GET_FUN(__glewMultiTexCoord3dvARB) +#define glMultiTexCoord3fARB GLEW_GET_FUN(__glewMultiTexCoord3fARB) +#define glMultiTexCoord3fvARB GLEW_GET_FUN(__glewMultiTexCoord3fvARB) +#define glMultiTexCoord3iARB GLEW_GET_FUN(__glewMultiTexCoord3iARB) +#define glMultiTexCoord3ivARB GLEW_GET_FUN(__glewMultiTexCoord3ivARB) +#define glMultiTexCoord3sARB GLEW_GET_FUN(__glewMultiTexCoord3sARB) +#define glMultiTexCoord3svARB GLEW_GET_FUN(__glewMultiTexCoord3svARB) +#define glMultiTexCoord4dARB GLEW_GET_FUN(__glewMultiTexCoord4dARB) +#define glMultiTexCoord4dvARB GLEW_GET_FUN(__glewMultiTexCoord4dvARB) +#define glMultiTexCoord4fARB GLEW_GET_FUN(__glewMultiTexCoord4fARB) +#define glMultiTexCoord4fvARB GLEW_GET_FUN(__glewMultiTexCoord4fvARB) +#define glMultiTexCoord4iARB GLEW_GET_FUN(__glewMultiTexCoord4iARB) +#define glMultiTexCoord4ivARB GLEW_GET_FUN(__glewMultiTexCoord4ivARB) +#define glMultiTexCoord4sARB GLEW_GET_FUN(__glewMultiTexCoord4sARB) +#define glMultiTexCoord4svARB GLEW_GET_FUN(__glewMultiTexCoord4svARB) + +#define GLEW_ARB_multitexture GLEW_GET_VAR(__GLEW_ARB_multitexture) + +#endif /* GL_ARB_multitexture */ + +/* ------------------------- GL_ARB_occlusion_query ------------------------ */ + +#ifndef GL_ARB_occlusion_query +#define GL_ARB_occlusion_query 1 + +#define GL_QUERY_COUNTER_BITS_ARB 0x8864 +#define GL_CURRENT_QUERY_ARB 0x8865 +#define GL_QUERY_RESULT_ARB 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 +#define GL_SAMPLES_PASSED_ARB 0x8914 + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDQUERYARBPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYARBPROC) (GLuint id); + +#define glBeginQueryARB GLEW_GET_FUN(__glewBeginQueryARB) +#define glDeleteQueriesARB GLEW_GET_FUN(__glewDeleteQueriesARB) +#define glEndQueryARB GLEW_GET_FUN(__glewEndQueryARB) +#define glGenQueriesARB GLEW_GET_FUN(__glewGenQueriesARB) +#define glGetQueryObjectivARB GLEW_GET_FUN(__glewGetQueryObjectivARB) +#define glGetQueryObjectuivARB GLEW_GET_FUN(__glewGetQueryObjectuivARB) +#define glGetQueryivARB GLEW_GET_FUN(__glewGetQueryivARB) +#define glIsQueryARB GLEW_GET_FUN(__glewIsQueryARB) + +#define GLEW_ARB_occlusion_query GLEW_GET_VAR(__GLEW_ARB_occlusion_query) + +#endif /* GL_ARB_occlusion_query */ + +/* ------------------------ GL_ARB_occlusion_query2 ------------------------ */ + +#ifndef GL_ARB_occlusion_query2 +#define GL_ARB_occlusion_query2 1 + +#define GL_ANY_SAMPLES_PASSED 0x8C2F + +#define GLEW_ARB_occlusion_query2 GLEW_GET_VAR(__GLEW_ARB_occlusion_query2) + +#endif /* GL_ARB_occlusion_query2 */ + +/* ----------------------- GL_ARB_pixel_buffer_object ---------------------- */ + +#ifndef GL_ARB_pixel_buffer_object +#define GL_ARB_pixel_buffer_object 1 + +#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF + +#define GLEW_ARB_pixel_buffer_object GLEW_GET_VAR(__GLEW_ARB_pixel_buffer_object) + +#endif /* GL_ARB_pixel_buffer_object */ + +/* ------------------------ GL_ARB_point_parameters ------------------------ */ + +#ifndef GL_ARB_point_parameters +#define GL_ARB_point_parameters 1 + +#define GL_POINT_SIZE_MIN_ARB 0x8126 +#define GL_POINT_SIZE_MAX_ARB 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat* params); + +#define glPointParameterfARB GLEW_GET_FUN(__glewPointParameterfARB) +#define glPointParameterfvARB GLEW_GET_FUN(__glewPointParameterfvARB) + +#define GLEW_ARB_point_parameters GLEW_GET_VAR(__GLEW_ARB_point_parameters) + +#endif /* GL_ARB_point_parameters */ + +/* -------------------------- GL_ARB_point_sprite -------------------------- */ + +#ifndef GL_ARB_point_sprite +#define GL_ARB_point_sprite 1 + +#define GL_POINT_SPRITE_ARB 0x8861 +#define GL_COORD_REPLACE_ARB 0x8862 + +#define GLEW_ARB_point_sprite GLEW_GET_VAR(__GLEW_ARB_point_sprite) + +#endif /* GL_ARB_point_sprite */ + +/* ------------------------ GL_ARB_provoking_vertex ------------------------ */ + +#ifndef GL_ARB_provoking_vertex +#define GL_ARB_provoking_vertex 1 + +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F + +typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXPROC) (GLenum mode); + +#define glProvokingVertex GLEW_GET_FUN(__glewProvokingVertex) + +#define GLEW_ARB_provoking_vertex GLEW_GET_VAR(__GLEW_ARB_provoking_vertex) + +#endif /* GL_ARB_provoking_vertex */ + +/* --------------------------- GL_ARB_robustness --------------------------- */ + +#ifndef GL_ARB_robustness +#define GL_ARB_robustness 1 + +#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB 0x00000004 +#define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 +#define GL_GUILTY_CONTEXT_RESET_ARB 0x8253 +#define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254 +#define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255 +#define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 +#define GL_NO_RESET_NOTIFICATION_ARB 0x8261 + +typedef GLenum (GLAPIENTRY * PFNGLGETGRAPHICSRESETSTATUSARBPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETNCOLORTABLEARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table); +typedef void (GLAPIENTRY * PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, GLsizei bufSize, void* img); +typedef void (GLAPIENTRY * PFNGLGETNCONVOLUTIONFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image); +typedef void (GLAPIENTRY * PFNGLGETNHISTOGRAMARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values); +typedef void (GLAPIENTRY * PFNGLGETNMAPDVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLdouble* v); +typedef void (GLAPIENTRY * PFNGLGETNMAPFVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLfloat* v); +typedef void (GLAPIENTRY * PFNGLGETNMAPIVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLint* v); +typedef void (GLAPIENTRY * PFNGLGETNMINMAXARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values); +typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPFVARBPROC) (GLenum map, GLsizei bufSize, GLfloat* values); +typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPUIVARBPROC) (GLenum map, GLsizei bufSize, GLuint* values); +typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPUSVARBPROC) (GLenum map, GLsizei bufSize, GLushort* values); +typedef void (GLAPIENTRY * PFNGLGETNPOLYGONSTIPPLEARBPROC) (GLsizei bufSize, GLubyte* pattern); +typedef void (GLAPIENTRY * PFNGLGETNSEPARABLEFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, GLvoid*column, GLvoid*span); +typedef void (GLAPIENTRY * PFNGLGETNTEXIMAGEARBPROC) (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img); +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMDVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMUIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLuint* params); +typedef void (GLAPIENTRY * PFNGLREADNPIXELSARBPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data); + +#define glGetGraphicsResetStatusARB GLEW_GET_FUN(__glewGetGraphicsResetStatusARB) +#define glGetnColorTableARB GLEW_GET_FUN(__glewGetnColorTableARB) +#define glGetnCompressedTexImageARB GLEW_GET_FUN(__glewGetnCompressedTexImageARB) +#define glGetnConvolutionFilterARB GLEW_GET_FUN(__glewGetnConvolutionFilterARB) +#define glGetnHistogramARB GLEW_GET_FUN(__glewGetnHistogramARB) +#define glGetnMapdvARB GLEW_GET_FUN(__glewGetnMapdvARB) +#define glGetnMapfvARB GLEW_GET_FUN(__glewGetnMapfvARB) +#define glGetnMapivARB GLEW_GET_FUN(__glewGetnMapivARB) +#define glGetnMinmaxARB GLEW_GET_FUN(__glewGetnMinmaxARB) +#define glGetnPixelMapfvARB GLEW_GET_FUN(__glewGetnPixelMapfvARB) +#define glGetnPixelMapuivARB GLEW_GET_FUN(__glewGetnPixelMapuivARB) +#define glGetnPixelMapusvARB GLEW_GET_FUN(__glewGetnPixelMapusvARB) +#define glGetnPolygonStippleARB GLEW_GET_FUN(__glewGetnPolygonStippleARB) +#define glGetnSeparableFilterARB GLEW_GET_FUN(__glewGetnSeparableFilterARB) +#define glGetnTexImageARB GLEW_GET_FUN(__glewGetnTexImageARB) +#define glGetnUniformdvARB GLEW_GET_FUN(__glewGetnUniformdvARB) +#define glGetnUniformfvARB GLEW_GET_FUN(__glewGetnUniformfvARB) +#define glGetnUniformivARB GLEW_GET_FUN(__glewGetnUniformivARB) +#define glGetnUniformuivARB GLEW_GET_FUN(__glewGetnUniformuivARB) +#define glReadnPixelsARB GLEW_GET_FUN(__glewReadnPixelsARB) + +#define GLEW_ARB_robustness GLEW_GET_VAR(__GLEW_ARB_robustness) + +#endif /* GL_ARB_robustness */ + +/* ------------------------- GL_ARB_sample_shading ------------------------- */ + +#ifndef GL_ARB_sample_shading +#define GL_ARB_sample_shading 1 + +#define GL_SAMPLE_SHADING_ARB 0x8C36 +#define GL_MIN_SAMPLE_SHADING_VALUE_ARB 0x8C37 + +typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGARBPROC) (GLclampf value); + +#define glMinSampleShadingARB GLEW_GET_FUN(__glewMinSampleShadingARB) + +#define GLEW_ARB_sample_shading GLEW_GET_VAR(__GLEW_ARB_sample_shading) + +#endif /* GL_ARB_sample_shading */ + +/* ------------------------- GL_ARB_sampler_objects ------------------------ */ + +#ifndef GL_ARB_sampler_objects +#define GL_ARB_sampler_objects 1 + +#define GL_SAMPLER_BINDING 0x8919 + +typedef void (GLAPIENTRY * PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler); +typedef void (GLAPIENTRY * PFNGLDELETESAMPLERSPROC) (GLsizei count, const GLuint * samplers); +typedef void (GLAPIENTRY * PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint* samplers); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISSAMPLERPROC) (GLuint sampler); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, const GLint* params); + +#define glBindSampler GLEW_GET_FUN(__glewBindSampler) +#define glDeleteSamplers GLEW_GET_FUN(__glewDeleteSamplers) +#define glGenSamplers GLEW_GET_FUN(__glewGenSamplers) +#define glGetSamplerParameterIiv GLEW_GET_FUN(__glewGetSamplerParameterIiv) +#define glGetSamplerParameterIuiv GLEW_GET_FUN(__glewGetSamplerParameterIuiv) +#define glGetSamplerParameterfv GLEW_GET_FUN(__glewGetSamplerParameterfv) +#define glGetSamplerParameteriv GLEW_GET_FUN(__glewGetSamplerParameteriv) +#define glIsSampler GLEW_GET_FUN(__glewIsSampler) +#define glSamplerParameterIiv GLEW_GET_FUN(__glewSamplerParameterIiv) +#define glSamplerParameterIuiv GLEW_GET_FUN(__glewSamplerParameterIuiv) +#define glSamplerParameterf GLEW_GET_FUN(__glewSamplerParameterf) +#define glSamplerParameterfv GLEW_GET_FUN(__glewSamplerParameterfv) +#define glSamplerParameteri GLEW_GET_FUN(__glewSamplerParameteri) +#define glSamplerParameteriv GLEW_GET_FUN(__glewSamplerParameteriv) + +#define GLEW_ARB_sampler_objects GLEW_GET_VAR(__GLEW_ARB_sampler_objects) + +#endif /* GL_ARB_sampler_objects */ + +/* ------------------------ GL_ARB_seamless_cube_map ----------------------- */ + +#ifndef GL_ARB_seamless_cube_map +#define GL_ARB_seamless_cube_map 1 + +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F + +#define GLEW_ARB_seamless_cube_map GLEW_GET_VAR(__GLEW_ARB_seamless_cube_map) + +#endif /* GL_ARB_seamless_cube_map */ + +/* --------------------- GL_ARB_separate_shader_objects -------------------- */ + +#ifndef GL_ARB_separate_shader_objects +#define GL_ARB_separate_shader_objects 1 + +#define GL_VERTEX_SHADER_BIT 0x00000001 +#define GL_FRAGMENT_SHADER_BIT 0x00000002 +#define GL_GEOMETRY_SHADER_BIT 0x00000004 +#define GL_TESS_CONTROL_SHADER_BIT 0x00000008 +#define GL_TESS_EVALUATION_SHADER_BIT 0x00000010 +#define GL_PROGRAM_SEPARABLE 0x8258 +#define GL_ACTIVE_PROGRAM 0x8259 +#define GL_PROGRAM_PIPELINE_BINDING 0x825A +#define GL_ALL_SHADER_BITS 0xFFFFFFFF + +typedef void (GLAPIENTRY * PFNGLACTIVESHADERPROGRAMPROC) (GLuint pipeline, GLuint program); +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMPIPELINEPROC) (GLuint pipeline); +typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROGRAMVPROC) (GLenum type, GLsizei count, const char ** strings); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPIPELINESPROC) (GLsizei n, const GLuint* pipelines); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMPIPELINESPROC) (GLsizei n, GLuint* pipelines); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPIPELINEINFOLOGPROC) (GLuint pipeline, GLsizei bufSize, GLsizei* length, char *infoLog); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPIPELINEIVPROC) (GLuint pipeline, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPIPELINEPROC) (GLuint pipeline); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DPROC) (GLuint program, GLint location, GLdouble x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FPROC) (GLuint program, GLint location, GLfloat x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IPROC) (GLuint program, GLint location, GLint x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIPROC) (GLuint program, GLint location, GLuint x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IPROC) (GLuint program, GLint location, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIPROC) (GLuint program, GLint location, GLuint x, GLuint y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIPROC) (GLuint program, GLint location, GLuint x, GLuint y, GLuint z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIPROC) (GLuint program, GLint location, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMSTAGESPROC) (GLuint pipeline, GLbitfield stages, GLuint program); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPIPELINEPROC) (GLuint pipeline); + +#define glActiveShaderProgram GLEW_GET_FUN(__glewActiveShaderProgram) +#define glBindProgramPipeline GLEW_GET_FUN(__glewBindProgramPipeline) +#define glCreateShaderProgramv GLEW_GET_FUN(__glewCreateShaderProgramv) +#define glDeleteProgramPipelines GLEW_GET_FUN(__glewDeleteProgramPipelines) +#define glGenProgramPipelines GLEW_GET_FUN(__glewGenProgramPipelines) +#define glGetProgramPipelineInfoLog GLEW_GET_FUN(__glewGetProgramPipelineInfoLog) +#define glGetProgramPipelineiv GLEW_GET_FUN(__glewGetProgramPipelineiv) +#define glIsProgramPipeline GLEW_GET_FUN(__glewIsProgramPipeline) +#define glProgramUniform1d GLEW_GET_FUN(__glewProgramUniform1d) +#define glProgramUniform1dv GLEW_GET_FUN(__glewProgramUniform1dv) +#define glProgramUniform1f GLEW_GET_FUN(__glewProgramUniform1f) +#define glProgramUniform1fv GLEW_GET_FUN(__glewProgramUniform1fv) +#define glProgramUniform1i GLEW_GET_FUN(__glewProgramUniform1i) +#define glProgramUniform1iv GLEW_GET_FUN(__glewProgramUniform1iv) +#define glProgramUniform1ui GLEW_GET_FUN(__glewProgramUniform1ui) +#define glProgramUniform1uiv GLEW_GET_FUN(__glewProgramUniform1uiv) +#define glProgramUniform2d GLEW_GET_FUN(__glewProgramUniform2d) +#define glProgramUniform2dv GLEW_GET_FUN(__glewProgramUniform2dv) +#define glProgramUniform2f GLEW_GET_FUN(__glewProgramUniform2f) +#define glProgramUniform2fv GLEW_GET_FUN(__glewProgramUniform2fv) +#define glProgramUniform2i GLEW_GET_FUN(__glewProgramUniform2i) +#define glProgramUniform2iv GLEW_GET_FUN(__glewProgramUniform2iv) +#define glProgramUniform2ui GLEW_GET_FUN(__glewProgramUniform2ui) +#define glProgramUniform2uiv GLEW_GET_FUN(__glewProgramUniform2uiv) +#define glProgramUniform3d GLEW_GET_FUN(__glewProgramUniform3d) +#define glProgramUniform3dv GLEW_GET_FUN(__glewProgramUniform3dv) +#define glProgramUniform3f GLEW_GET_FUN(__glewProgramUniform3f) +#define glProgramUniform3fv GLEW_GET_FUN(__glewProgramUniform3fv) +#define glProgramUniform3i GLEW_GET_FUN(__glewProgramUniform3i) +#define glProgramUniform3iv GLEW_GET_FUN(__glewProgramUniform3iv) +#define glProgramUniform3ui GLEW_GET_FUN(__glewProgramUniform3ui) +#define glProgramUniform3uiv GLEW_GET_FUN(__glewProgramUniform3uiv) +#define glProgramUniform4d GLEW_GET_FUN(__glewProgramUniform4d) +#define glProgramUniform4dv GLEW_GET_FUN(__glewProgramUniform4dv) +#define glProgramUniform4f GLEW_GET_FUN(__glewProgramUniform4f) +#define glProgramUniform4fv GLEW_GET_FUN(__glewProgramUniform4fv) +#define glProgramUniform4i GLEW_GET_FUN(__glewProgramUniform4i) +#define glProgramUniform4iv GLEW_GET_FUN(__glewProgramUniform4iv) +#define glProgramUniform4ui GLEW_GET_FUN(__glewProgramUniform4ui) +#define glProgramUniform4uiv GLEW_GET_FUN(__glewProgramUniform4uiv) +#define glProgramUniformMatrix2dv GLEW_GET_FUN(__glewProgramUniformMatrix2dv) +#define glProgramUniformMatrix2fv GLEW_GET_FUN(__glewProgramUniformMatrix2fv) +#define glProgramUniformMatrix2x3dv GLEW_GET_FUN(__glewProgramUniformMatrix2x3dv) +#define glProgramUniformMatrix2x3fv GLEW_GET_FUN(__glewProgramUniformMatrix2x3fv) +#define glProgramUniformMatrix2x4dv GLEW_GET_FUN(__glewProgramUniformMatrix2x4dv) +#define glProgramUniformMatrix2x4fv GLEW_GET_FUN(__glewProgramUniformMatrix2x4fv) +#define glProgramUniformMatrix3dv GLEW_GET_FUN(__glewProgramUniformMatrix3dv) +#define glProgramUniformMatrix3fv GLEW_GET_FUN(__glewProgramUniformMatrix3fv) +#define glProgramUniformMatrix3x2dv GLEW_GET_FUN(__glewProgramUniformMatrix3x2dv) +#define glProgramUniformMatrix3x2fv GLEW_GET_FUN(__glewProgramUniformMatrix3x2fv) +#define glProgramUniformMatrix3x4dv GLEW_GET_FUN(__glewProgramUniformMatrix3x4dv) +#define glProgramUniformMatrix3x4fv GLEW_GET_FUN(__glewProgramUniformMatrix3x4fv) +#define glProgramUniformMatrix4dv GLEW_GET_FUN(__glewProgramUniformMatrix4dv) +#define glProgramUniformMatrix4fv GLEW_GET_FUN(__glewProgramUniformMatrix4fv) +#define glProgramUniformMatrix4x2dv GLEW_GET_FUN(__glewProgramUniformMatrix4x2dv) +#define glProgramUniformMatrix4x2fv GLEW_GET_FUN(__glewProgramUniformMatrix4x2fv) +#define glProgramUniformMatrix4x3dv GLEW_GET_FUN(__glewProgramUniformMatrix4x3dv) +#define glProgramUniformMatrix4x3fv GLEW_GET_FUN(__glewProgramUniformMatrix4x3fv) +#define glUseProgramStages GLEW_GET_FUN(__glewUseProgramStages) +#define glValidateProgramPipeline GLEW_GET_FUN(__glewValidateProgramPipeline) + +#define GLEW_ARB_separate_shader_objects GLEW_GET_VAR(__GLEW_ARB_separate_shader_objects) + +#endif /* GL_ARB_separate_shader_objects */ + +/* --------------------- GL_ARB_shader_atomic_counters --------------------- */ + +#ifndef GL_ARB_shader_atomic_counters +#define GL_ARB_shader_atomic_counters 1 + +#define GL_ATOMIC_COUNTER_BUFFER 0x92C0 +#define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1 +#define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2 +#define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3 +#define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE 0x92C4 +#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS 0x92C5 +#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES 0x92C6 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER 0x92C7 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER 0x92C8 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER 0x92C9 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER 0x92CA +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER 0x92CB +#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF +#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0 +#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1 +#define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS 0x92D5 +#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6 +#define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7 +#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8 +#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9 +#define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX 0x92DA +#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB +#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC + +typedef void (GLAPIENTRY * PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC) (GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); + +#define glGetActiveAtomicCounterBufferiv GLEW_GET_FUN(__glewGetActiveAtomicCounterBufferiv) + +#define GLEW_ARB_shader_atomic_counters GLEW_GET_VAR(__GLEW_ARB_shader_atomic_counters) + +#endif /* GL_ARB_shader_atomic_counters */ + +/* ----------------------- GL_ARB_shader_bit_encoding ---------------------- */ + +#ifndef GL_ARB_shader_bit_encoding +#define GL_ARB_shader_bit_encoding 1 + +#define GLEW_ARB_shader_bit_encoding GLEW_GET_VAR(__GLEW_ARB_shader_bit_encoding) + +#endif /* GL_ARB_shader_bit_encoding */ + +/* --------------------- GL_ARB_shader_image_load_store -------------------- */ + +#ifndef GL_ARB_shader_image_load_store +#define GL_ARB_shader_image_load_store 1 + +#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001 +#define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002 +#define GL_UNIFORM_BARRIER_BIT 0x00000004 +#define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008 +#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020 +#define GL_COMMAND_BARRIER_BIT 0x00000040 +#define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080 +#define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100 +#define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200 +#define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400 +#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800 +#define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000 +#define GL_MAX_IMAGE_UNITS 0x8F38 +#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS 0x8F39 +#define GL_IMAGE_BINDING_NAME 0x8F3A +#define GL_IMAGE_BINDING_LEVEL 0x8F3B +#define GL_IMAGE_BINDING_LAYERED 0x8F3C +#define GL_IMAGE_BINDING_LAYER 0x8F3D +#define GL_IMAGE_BINDING_ACCESS 0x8F3E +#define GL_IMAGE_1D 0x904C +#define GL_IMAGE_2D 0x904D +#define GL_IMAGE_3D 0x904E +#define GL_IMAGE_2D_RECT 0x904F +#define GL_IMAGE_CUBE 0x9050 +#define GL_IMAGE_BUFFER 0x9051 +#define GL_IMAGE_1D_ARRAY 0x9052 +#define GL_IMAGE_2D_ARRAY 0x9053 +#define GL_IMAGE_CUBE_MAP_ARRAY 0x9054 +#define GL_IMAGE_2D_MULTISAMPLE 0x9055 +#define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056 +#define GL_INT_IMAGE_1D 0x9057 +#define GL_INT_IMAGE_2D 0x9058 +#define GL_INT_IMAGE_3D 0x9059 +#define GL_INT_IMAGE_2D_RECT 0x905A +#define GL_INT_IMAGE_CUBE 0x905B +#define GL_INT_IMAGE_BUFFER 0x905C +#define GL_INT_IMAGE_1D_ARRAY 0x905D +#define GL_INT_IMAGE_2D_ARRAY 0x905E +#define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F +#define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060 +#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061 +#define GL_UNSIGNED_INT_IMAGE_1D 0x9062 +#define GL_UNSIGNED_INT_IMAGE_2D 0x9063 +#define GL_UNSIGNED_INT_IMAGE_3D 0x9064 +#define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065 +#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066 +#define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067 +#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068 +#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069 +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C +#define GL_MAX_IMAGE_SAMPLES 0x906D +#define GL_IMAGE_BINDING_FORMAT 0x906E +#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7 +#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8 +#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9 +#define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS 0x90CD +#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE +#define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF +#define GL_ALL_BARRIER_BITS 0xFFFFFFFF + +typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTUREPROC) (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +typedef void (GLAPIENTRY * PFNGLMEMORYBARRIERPROC) (GLbitfield barriers); + +#define glBindImageTexture GLEW_GET_FUN(__glewBindImageTexture) +#define glMemoryBarrier GLEW_GET_FUN(__glewMemoryBarrier) + +#define GLEW_ARB_shader_image_load_store GLEW_GET_VAR(__GLEW_ARB_shader_image_load_store) + +#endif /* GL_ARB_shader_image_load_store */ + +/* ------------------------- GL_ARB_shader_objects ------------------------- */ + +#ifndef GL_ARB_shader_objects +#define GL_ARB_shader_objects 1 + +#define GL_PROGRAM_OBJECT_ARB 0x8B40 +#define GL_SHADER_OBJECT_ARB 0x8B48 +#define GL_OBJECT_TYPE_ARB 0x8B4E +#define GL_OBJECT_SUBTYPE_ARB 0x8B4F +#define GL_FLOAT_VEC2_ARB 0x8B50 +#define GL_FLOAT_VEC3_ARB 0x8B51 +#define GL_FLOAT_VEC4_ARB 0x8B52 +#define GL_INT_VEC2_ARB 0x8B53 +#define GL_INT_VEC3_ARB 0x8B54 +#define GL_INT_VEC4_ARB 0x8B55 +#define GL_BOOL_ARB 0x8B56 +#define GL_BOOL_VEC2_ARB 0x8B57 +#define GL_BOOL_VEC3_ARB 0x8B58 +#define GL_BOOL_VEC4_ARB 0x8B59 +#define GL_FLOAT_MAT2_ARB 0x8B5A +#define GL_FLOAT_MAT3_ARB 0x8B5B +#define GL_FLOAT_MAT4_ARB 0x8B5C +#define GL_SAMPLER_1D_ARB 0x8B5D +#define GL_SAMPLER_2D_ARB 0x8B5E +#define GL_SAMPLER_3D_ARB 0x8B5F +#define GL_SAMPLER_CUBE_ARB 0x8B60 +#define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 +#define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 +#define GL_SAMPLER_2D_RECT_ARB 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 +#define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 +#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 +#define GL_OBJECT_LINK_STATUS_ARB 0x8B82 +#define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 +#define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 +#define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 +#define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 +#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 +#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 + +typedef char GLcharARB; +typedef unsigned int GLhandleARB; + +typedef void (GLAPIENTRY * PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATEPROGRAMOBJECTARBPROC) (void); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); +typedef void (GLAPIENTRY * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB *obj); +typedef GLhandleARB (GLAPIENTRY * PFNGLGETHANDLEARBPROC) (GLenum pname); +typedef void (GLAPIENTRY * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *infoLog); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *source); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint* params); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint *length); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); + +#define glAttachObjectARB GLEW_GET_FUN(__glewAttachObjectARB) +#define glCompileShaderARB GLEW_GET_FUN(__glewCompileShaderARB) +#define glCreateProgramObjectARB GLEW_GET_FUN(__glewCreateProgramObjectARB) +#define glCreateShaderObjectARB GLEW_GET_FUN(__glewCreateShaderObjectARB) +#define glDeleteObjectARB GLEW_GET_FUN(__glewDeleteObjectARB) +#define glDetachObjectARB GLEW_GET_FUN(__glewDetachObjectARB) +#define glGetActiveUniformARB GLEW_GET_FUN(__glewGetActiveUniformARB) +#define glGetAttachedObjectsARB GLEW_GET_FUN(__glewGetAttachedObjectsARB) +#define glGetHandleARB GLEW_GET_FUN(__glewGetHandleARB) +#define glGetInfoLogARB GLEW_GET_FUN(__glewGetInfoLogARB) +#define glGetObjectParameterfvARB GLEW_GET_FUN(__glewGetObjectParameterfvARB) +#define glGetObjectParameterivARB GLEW_GET_FUN(__glewGetObjectParameterivARB) +#define glGetShaderSourceARB GLEW_GET_FUN(__glewGetShaderSourceARB) +#define glGetUniformLocationARB GLEW_GET_FUN(__glewGetUniformLocationARB) +#define glGetUniformfvARB GLEW_GET_FUN(__glewGetUniformfvARB) +#define glGetUniformivARB GLEW_GET_FUN(__glewGetUniformivARB) +#define glLinkProgramARB GLEW_GET_FUN(__glewLinkProgramARB) +#define glShaderSourceARB GLEW_GET_FUN(__glewShaderSourceARB) +#define glUniform1fARB GLEW_GET_FUN(__glewUniform1fARB) +#define glUniform1fvARB GLEW_GET_FUN(__glewUniform1fvARB) +#define glUniform1iARB GLEW_GET_FUN(__glewUniform1iARB) +#define glUniform1ivARB GLEW_GET_FUN(__glewUniform1ivARB) +#define glUniform2fARB GLEW_GET_FUN(__glewUniform2fARB) +#define glUniform2fvARB GLEW_GET_FUN(__glewUniform2fvARB) +#define glUniform2iARB GLEW_GET_FUN(__glewUniform2iARB) +#define glUniform2ivARB GLEW_GET_FUN(__glewUniform2ivARB) +#define glUniform3fARB GLEW_GET_FUN(__glewUniform3fARB) +#define glUniform3fvARB GLEW_GET_FUN(__glewUniform3fvARB) +#define glUniform3iARB GLEW_GET_FUN(__glewUniform3iARB) +#define glUniform3ivARB GLEW_GET_FUN(__glewUniform3ivARB) +#define glUniform4fARB GLEW_GET_FUN(__glewUniform4fARB) +#define glUniform4fvARB GLEW_GET_FUN(__glewUniform4fvARB) +#define glUniform4iARB GLEW_GET_FUN(__glewUniform4iARB) +#define glUniform4ivARB GLEW_GET_FUN(__glewUniform4ivARB) +#define glUniformMatrix2fvARB GLEW_GET_FUN(__glewUniformMatrix2fvARB) +#define glUniformMatrix3fvARB GLEW_GET_FUN(__glewUniformMatrix3fvARB) +#define glUniformMatrix4fvARB GLEW_GET_FUN(__glewUniformMatrix4fvARB) +#define glUseProgramObjectARB GLEW_GET_FUN(__glewUseProgramObjectARB) +#define glValidateProgramARB GLEW_GET_FUN(__glewValidateProgramARB) + +#define GLEW_ARB_shader_objects GLEW_GET_VAR(__GLEW_ARB_shader_objects) + +#endif /* GL_ARB_shader_objects */ + +/* ------------------------ GL_ARB_shader_precision ------------------------ */ + +#ifndef GL_ARB_shader_precision +#define GL_ARB_shader_precision 1 + +#define GLEW_ARB_shader_precision GLEW_GET_VAR(__GLEW_ARB_shader_precision) + +#endif /* GL_ARB_shader_precision */ + +/* ---------------------- GL_ARB_shader_stencil_export --------------------- */ + +#ifndef GL_ARB_shader_stencil_export +#define GL_ARB_shader_stencil_export 1 + +#define GLEW_ARB_shader_stencil_export GLEW_GET_VAR(__GLEW_ARB_shader_stencil_export) + +#endif /* GL_ARB_shader_stencil_export */ + +/* ------------------------ GL_ARB_shader_subroutine ----------------------- */ + +#ifndef GL_ARB_shader_subroutine +#define GL_ARB_shader_subroutine 1 + +#define GL_ACTIVE_SUBROUTINES 0x8DE5 +#define GL_ACTIVE_SUBROUTINE_UNIFORMS 0x8DE6 +#define GL_MAX_SUBROUTINES 0x8DE7 +#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8 +#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47 +#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH 0x8E48 +#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49 +#define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A +#define GL_COMPATIBLE_SUBROUTINES 0x8E4B + +typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINENAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char *name); +typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char *name); +typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTAGEIVPROC) (GLuint program, GLenum shadertype, GLenum pname, GLint* values); +typedef GLuint (GLAPIENTRY * PFNGLGETSUBROUTINEINDEXPROC) (GLuint program, GLenum shadertype, const char* name); +typedef GLint (GLAPIENTRY * PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) (GLuint program, GLenum shadertype, const char* name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMSUBROUTINEUIVPROC) (GLenum shadertype, GLint location, GLuint* params); +typedef void (GLAPIENTRY * PFNGLUNIFORMSUBROUTINESUIVPROC) (GLenum shadertype, GLsizei count, const GLuint* indices); + +#define glGetActiveSubroutineName GLEW_GET_FUN(__glewGetActiveSubroutineName) +#define glGetActiveSubroutineUniformName GLEW_GET_FUN(__glewGetActiveSubroutineUniformName) +#define glGetActiveSubroutineUniformiv GLEW_GET_FUN(__glewGetActiveSubroutineUniformiv) +#define glGetProgramStageiv GLEW_GET_FUN(__glewGetProgramStageiv) +#define glGetSubroutineIndex GLEW_GET_FUN(__glewGetSubroutineIndex) +#define glGetSubroutineUniformLocation GLEW_GET_FUN(__glewGetSubroutineUniformLocation) +#define glGetUniformSubroutineuiv GLEW_GET_FUN(__glewGetUniformSubroutineuiv) +#define glUniformSubroutinesuiv GLEW_GET_FUN(__glewUniformSubroutinesuiv) + +#define GLEW_ARB_shader_subroutine GLEW_GET_VAR(__GLEW_ARB_shader_subroutine) + +#endif /* GL_ARB_shader_subroutine */ + +/* ----------------------- GL_ARB_shader_texture_lod ----------------------- */ + +#ifndef GL_ARB_shader_texture_lod +#define GL_ARB_shader_texture_lod 1 + +#define GLEW_ARB_shader_texture_lod GLEW_GET_VAR(__GLEW_ARB_shader_texture_lod) + +#endif /* GL_ARB_shader_texture_lod */ + +/* ---------------------- GL_ARB_shading_language_100 ---------------------- */ + +#ifndef GL_ARB_shading_language_100 +#define GL_ARB_shading_language_100 1 + +#define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C + +#define GLEW_ARB_shading_language_100 GLEW_GET_VAR(__GLEW_ARB_shading_language_100) + +#endif /* GL_ARB_shading_language_100 */ + +/* -------------------- GL_ARB_shading_language_420pack -------------------- */ + +#ifndef GL_ARB_shading_language_420pack +#define GL_ARB_shading_language_420pack 1 + +#define GLEW_ARB_shading_language_420pack GLEW_GET_VAR(__GLEW_ARB_shading_language_420pack) + +#endif /* GL_ARB_shading_language_420pack */ + +/* -------------------- GL_ARB_shading_language_include -------------------- */ + +#ifndef GL_ARB_shading_language_include +#define GL_ARB_shading_language_include 1 + +#define GL_SHADER_INCLUDE_ARB 0x8DAE +#define GL_NAMED_STRING_LENGTH_ARB 0x8DE9 +#define GL_NAMED_STRING_TYPE_ARB 0x8DEA + +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERINCLUDEARBPROC) (GLuint shader, GLsizei count, const char ** path, const GLint *length); +typedef void (GLAPIENTRY * PFNGLDELETENAMEDSTRINGARBPROC) (GLint namelen, const char* name); +typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGARBPROC) (GLint namelen, const char* name, GLsizei bufSize, GLint *stringlen, char *string); +typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGIVARBPROC) (GLint namelen, const char* name, GLenum pname, GLint *params); +typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDSTRINGARBPROC) (GLint namelen, const char* name); +typedef void (GLAPIENTRY * PFNGLNAMEDSTRINGARBPROC) (GLenum type, GLint namelen, const char* name, GLint stringlen, const char *string); + +#define glCompileShaderIncludeARB GLEW_GET_FUN(__glewCompileShaderIncludeARB) +#define glDeleteNamedStringARB GLEW_GET_FUN(__glewDeleteNamedStringARB) +#define glGetNamedStringARB GLEW_GET_FUN(__glewGetNamedStringARB) +#define glGetNamedStringivARB GLEW_GET_FUN(__glewGetNamedStringivARB) +#define glIsNamedStringARB GLEW_GET_FUN(__glewIsNamedStringARB) +#define glNamedStringARB GLEW_GET_FUN(__glewNamedStringARB) + +#define GLEW_ARB_shading_language_include GLEW_GET_VAR(__GLEW_ARB_shading_language_include) + +#endif /* GL_ARB_shading_language_include */ + +/* -------------------- GL_ARB_shading_language_packing -------------------- */ + +#ifndef GL_ARB_shading_language_packing +#define GL_ARB_shading_language_packing 1 + +#define GLEW_ARB_shading_language_packing GLEW_GET_VAR(__GLEW_ARB_shading_language_packing) + +#endif /* GL_ARB_shading_language_packing */ + +/* ----------------------------- GL_ARB_shadow ----------------------------- */ + +#ifndef GL_ARB_shadow +#define GL_ARB_shadow 1 + +#define GL_TEXTURE_COMPARE_MODE_ARB 0x884C +#define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D +#define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E + +#define GLEW_ARB_shadow GLEW_GET_VAR(__GLEW_ARB_shadow) + +#endif /* GL_ARB_shadow */ + +/* ------------------------- GL_ARB_shadow_ambient ------------------------- */ + +#ifndef GL_ARB_shadow_ambient +#define GL_ARB_shadow_ambient 1 + +#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF + +#define GLEW_ARB_shadow_ambient GLEW_GET_VAR(__GLEW_ARB_shadow_ambient) + +#endif /* GL_ARB_shadow_ambient */ + +/* ------------------------------ GL_ARB_sync ------------------------------ */ + +#ifndef GL_ARB_sync +#define GL_ARB_sync 1 + +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF + +typedef GLenum (GLAPIENTRY * PFNGLCLIENTWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout); +typedef void (GLAPIENTRY * PFNGLDELETESYNCPROC) (GLsync GLsync); +typedef GLsync (GLAPIENTRY * PFNGLFENCESYNCPROC) (GLenum condition,GLbitfield flags); +typedef void (GLAPIENTRY * PFNGLGETINTEGER64VPROC) (GLenum pname, GLint64* params); +typedef void (GLAPIENTRY * PFNGLGETSYNCIVPROC) (GLsync GLsync,GLenum pname,GLsizei bufSize,GLsizei* length, GLint *values); +typedef GLboolean (GLAPIENTRY * PFNGLISSYNCPROC) (GLsync GLsync); +typedef void (GLAPIENTRY * PFNGLWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout); + +#define glClientWaitSync GLEW_GET_FUN(__glewClientWaitSync) +#define glDeleteSync GLEW_GET_FUN(__glewDeleteSync) +#define glFenceSync GLEW_GET_FUN(__glewFenceSync) +#define glGetInteger64v GLEW_GET_FUN(__glewGetInteger64v) +#define glGetSynciv GLEW_GET_FUN(__glewGetSynciv) +#define glIsSync GLEW_GET_FUN(__glewIsSync) +#define glWaitSync GLEW_GET_FUN(__glewWaitSync) + +#define GLEW_ARB_sync GLEW_GET_VAR(__GLEW_ARB_sync) + +#endif /* GL_ARB_sync */ + +/* ----------------------- GL_ARB_tessellation_shader ---------------------- */ + +#ifndef GL_ARB_tessellation_shader +#define GL_ARB_tessellation_shader 1 + +#define GL_PATCHES 0xE +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1 +#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C +#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D +#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E +#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F +#define GL_PATCH_VERTICES 0x8E72 +#define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73 +#define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74 +#define GL_TESS_CONTROL_OUTPUT_VERTICES 0x8E75 +#define GL_TESS_GEN_MODE 0x8E76 +#define GL_TESS_GEN_SPACING 0x8E77 +#define GL_TESS_GEN_VERTEX_ORDER 0x8E78 +#define GL_TESS_GEN_POINT_MODE 0x8E79 +#define GL_ISOLINES 0x8E7A +#define GL_FRACTIONAL_ODD 0x8E7B +#define GL_FRACTIONAL_EVEN 0x8E7C +#define GL_MAX_PATCH_VERTICES 0x8E7D +#define GL_MAX_TESS_GEN_LEVEL 0x8E7E +#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F +#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80 +#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81 +#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82 +#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83 +#define GL_MAX_TESS_PATCH_COMPONENTS 0x8E84 +#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85 +#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86 +#define GL_TESS_EVALUATION_SHADER 0x8E87 +#define GL_TESS_CONTROL_SHADER 0x8E88 +#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89 +#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A + +typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERFVPROC) (GLenum pname, const GLfloat* values); +typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERIPROC) (GLenum pname, GLint value); + +#define glPatchParameterfv GLEW_GET_FUN(__glewPatchParameterfv) +#define glPatchParameteri GLEW_GET_FUN(__glewPatchParameteri) + +#define GLEW_ARB_tessellation_shader GLEW_GET_VAR(__GLEW_ARB_tessellation_shader) + +#endif /* GL_ARB_tessellation_shader */ + +/* ---------------------- GL_ARB_texture_border_clamp ---------------------- */ + +#ifndef GL_ARB_texture_border_clamp +#define GL_ARB_texture_border_clamp 1 + +#define GL_CLAMP_TO_BORDER_ARB 0x812D + +#define GLEW_ARB_texture_border_clamp GLEW_GET_VAR(__GLEW_ARB_texture_border_clamp) + +#endif /* GL_ARB_texture_border_clamp */ + +/* ---------------------- GL_ARB_texture_buffer_object --------------------- */ + +#ifndef GL_ARB_texture_buffer_object +#define GL_ARB_texture_buffer_object 1 + +#define GL_TEXTURE_BUFFER_ARB 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_ARB 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_ARB 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB 0x8C2D +#define GL_TEXTURE_BUFFER_FORMAT_ARB 0x8C2E + +typedef void (GLAPIENTRY * PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum internalformat, GLuint buffer); + +#define glTexBufferARB GLEW_GET_FUN(__glewTexBufferARB) + +#define GLEW_ARB_texture_buffer_object GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object) + +#endif /* GL_ARB_texture_buffer_object */ + +/* ------------------- GL_ARB_texture_buffer_object_rgb32 ------------------ */ + +#ifndef GL_ARB_texture_buffer_object_rgb32 +#define GL_ARB_texture_buffer_object_rgb32 1 + +#define GLEW_ARB_texture_buffer_object_rgb32 GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object_rgb32) + +#endif /* GL_ARB_texture_buffer_object_rgb32 */ + +/* ----------------------- GL_ARB_texture_compression ---------------------- */ + +#ifndef GL_ARB_texture_compression +#define GL_ARB_texture_compression 1 + +#define GL_COMPRESSED_ALPHA_ARB 0x84E9 +#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB +#define GL_COMPRESSED_INTENSITY_ARB 0x84EC +#define GL_COMPRESSED_RGB_ARB 0x84ED +#define GL_COMPRESSED_RGBA_ARB 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 +#define GL_TEXTURE_COMPRESSED_ARB 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 + +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, void* img); + +#define glCompressedTexImage1DARB GLEW_GET_FUN(__glewCompressedTexImage1DARB) +#define glCompressedTexImage2DARB GLEW_GET_FUN(__glewCompressedTexImage2DARB) +#define glCompressedTexImage3DARB GLEW_GET_FUN(__glewCompressedTexImage3DARB) +#define glCompressedTexSubImage1DARB GLEW_GET_FUN(__glewCompressedTexSubImage1DARB) +#define glCompressedTexSubImage2DARB GLEW_GET_FUN(__glewCompressedTexSubImage2DARB) +#define glCompressedTexSubImage3DARB GLEW_GET_FUN(__glewCompressedTexSubImage3DARB) +#define glGetCompressedTexImageARB GLEW_GET_FUN(__glewGetCompressedTexImageARB) + +#define GLEW_ARB_texture_compression GLEW_GET_VAR(__GLEW_ARB_texture_compression) + +#endif /* GL_ARB_texture_compression */ + +/* -------------------- GL_ARB_texture_compression_bptc -------------------- */ + +#ifndef GL_ARB_texture_compression_bptc +#define GL_ARB_texture_compression_bptc 1 + +#define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C +#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D +#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E +#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F + +#define GLEW_ARB_texture_compression_bptc GLEW_GET_VAR(__GLEW_ARB_texture_compression_bptc) + +#endif /* GL_ARB_texture_compression_bptc */ + +/* -------------------- GL_ARB_texture_compression_rgtc -------------------- */ + +#ifndef GL_ARB_texture_compression_rgtc +#define GL_ARB_texture_compression_rgtc 1 + +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE + +#define GLEW_ARB_texture_compression_rgtc GLEW_GET_VAR(__GLEW_ARB_texture_compression_rgtc) + +#endif /* GL_ARB_texture_compression_rgtc */ + +/* ------------------------ GL_ARB_texture_cube_map ------------------------ */ + +#ifndef GL_ARB_texture_cube_map +#define GL_ARB_texture_cube_map 1 + +#define GL_NORMAL_MAP_ARB 0x8511 +#define GL_REFLECTION_MAP_ARB 0x8512 +#define GL_TEXTURE_CUBE_MAP_ARB 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C + +#define GLEW_ARB_texture_cube_map GLEW_GET_VAR(__GLEW_ARB_texture_cube_map) + +#endif /* GL_ARB_texture_cube_map */ + +/* --------------------- GL_ARB_texture_cube_map_array --------------------- */ + +#ifndef GL_ARB_texture_cube_map_array +#define GL_ARB_texture_cube_map_array 1 + +#define GL_TEXTURE_CUBE_MAP_ARRAY_ARB 0x9009 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB 0x900A +#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB 0x900B +#define GL_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900E +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900F + +#define GLEW_ARB_texture_cube_map_array GLEW_GET_VAR(__GLEW_ARB_texture_cube_map_array) + +#endif /* GL_ARB_texture_cube_map_array */ + +/* ------------------------- GL_ARB_texture_env_add ------------------------ */ + +#ifndef GL_ARB_texture_env_add +#define GL_ARB_texture_env_add 1 + +#define GLEW_ARB_texture_env_add GLEW_GET_VAR(__GLEW_ARB_texture_env_add) + +#endif /* GL_ARB_texture_env_add */ + +/* ----------------------- GL_ARB_texture_env_combine ---------------------- */ + +#ifndef GL_ARB_texture_env_combine +#define GL_ARB_texture_env_combine 1 + +#define GL_SUBTRACT_ARB 0x84E7 +#define GL_COMBINE_ARB 0x8570 +#define GL_COMBINE_RGB_ARB 0x8571 +#define GL_COMBINE_ALPHA_ARB 0x8572 +#define GL_RGB_SCALE_ARB 0x8573 +#define GL_ADD_SIGNED_ARB 0x8574 +#define GL_INTERPOLATE_ARB 0x8575 +#define GL_CONSTANT_ARB 0x8576 +#define GL_PRIMARY_COLOR_ARB 0x8577 +#define GL_PREVIOUS_ARB 0x8578 +#define GL_SOURCE0_RGB_ARB 0x8580 +#define GL_SOURCE1_RGB_ARB 0x8581 +#define GL_SOURCE2_RGB_ARB 0x8582 +#define GL_SOURCE0_ALPHA_ARB 0x8588 +#define GL_SOURCE1_ALPHA_ARB 0x8589 +#define GL_SOURCE2_ALPHA_ARB 0x858A +#define GL_OPERAND0_RGB_ARB 0x8590 +#define GL_OPERAND1_RGB_ARB 0x8591 +#define GL_OPERAND2_RGB_ARB 0x8592 +#define GL_OPERAND0_ALPHA_ARB 0x8598 +#define GL_OPERAND1_ALPHA_ARB 0x8599 +#define GL_OPERAND2_ALPHA_ARB 0x859A + +#define GLEW_ARB_texture_env_combine GLEW_GET_VAR(__GLEW_ARB_texture_env_combine) + +#endif /* GL_ARB_texture_env_combine */ + +/* ---------------------- GL_ARB_texture_env_crossbar ---------------------- */ + +#ifndef GL_ARB_texture_env_crossbar +#define GL_ARB_texture_env_crossbar 1 + +#define GLEW_ARB_texture_env_crossbar GLEW_GET_VAR(__GLEW_ARB_texture_env_crossbar) + +#endif /* GL_ARB_texture_env_crossbar */ + +/* ------------------------ GL_ARB_texture_env_dot3 ------------------------ */ + +#ifndef GL_ARB_texture_env_dot3 +#define GL_ARB_texture_env_dot3 1 + +#define GL_DOT3_RGB_ARB 0x86AE +#define GL_DOT3_RGBA_ARB 0x86AF + +#define GLEW_ARB_texture_env_dot3 GLEW_GET_VAR(__GLEW_ARB_texture_env_dot3) + +#endif /* GL_ARB_texture_env_dot3 */ + +/* -------------------------- GL_ARB_texture_float ------------------------- */ + +#ifndef GL_ARB_texture_float +#define GL_ARB_texture_float 1 + +#define GL_RGBA32F_ARB 0x8814 +#define GL_RGB32F_ARB 0x8815 +#define GL_ALPHA32F_ARB 0x8816 +#define GL_INTENSITY32F_ARB 0x8817 +#define GL_LUMINANCE32F_ARB 0x8818 +#define GL_LUMINANCE_ALPHA32F_ARB 0x8819 +#define GL_RGBA16F_ARB 0x881A +#define GL_RGB16F_ARB 0x881B +#define GL_ALPHA16F_ARB 0x881C +#define GL_INTENSITY16F_ARB 0x881D +#define GL_LUMINANCE16F_ARB 0x881E +#define GL_LUMINANCE_ALPHA16F_ARB 0x881F +#define GL_TEXTURE_RED_TYPE_ARB 0x8C10 +#define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11 +#define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13 +#define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15 +#define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16 +#define GL_UNSIGNED_NORMALIZED_ARB 0x8C17 + +#define GLEW_ARB_texture_float GLEW_GET_VAR(__GLEW_ARB_texture_float) + +#endif /* GL_ARB_texture_float */ + +/* ------------------------- GL_ARB_texture_gather ------------------------- */ + +#ifndef GL_ARB_texture_gather +#define GL_ARB_texture_gather 1 + +#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5E +#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5F +#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB 0x8F9F + +#define GLEW_ARB_texture_gather GLEW_GET_VAR(__GLEW_ARB_texture_gather) + +#endif /* GL_ARB_texture_gather */ + +/* --------------------- GL_ARB_texture_mirrored_repeat -------------------- */ + +#ifndef GL_ARB_texture_mirrored_repeat +#define GL_ARB_texture_mirrored_repeat 1 + +#define GL_MIRRORED_REPEAT_ARB 0x8370 + +#define GLEW_ARB_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_ARB_texture_mirrored_repeat) + +#endif /* GL_ARB_texture_mirrored_repeat */ + +/* ----------------------- GL_ARB_texture_multisample ---------------------- */ + +#ifndef GL_ARB_texture_multisample +#define GL_ARB_texture_multisample 1 + +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 + +typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVPROC) (GLenum pname, GLuint index, GLfloat* val); +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKIPROC) (GLuint index, GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE2DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); + +#define glGetMultisamplefv GLEW_GET_FUN(__glewGetMultisamplefv) +#define glSampleMaski GLEW_GET_FUN(__glewSampleMaski) +#define glTexImage2DMultisample GLEW_GET_FUN(__glewTexImage2DMultisample) +#define glTexImage3DMultisample GLEW_GET_FUN(__glewTexImage3DMultisample) + +#define GLEW_ARB_texture_multisample GLEW_GET_VAR(__GLEW_ARB_texture_multisample) + +#endif /* GL_ARB_texture_multisample */ + +/* -------------------- GL_ARB_texture_non_power_of_two -------------------- */ + +#ifndef GL_ARB_texture_non_power_of_two +#define GL_ARB_texture_non_power_of_two 1 + +#define GLEW_ARB_texture_non_power_of_two GLEW_GET_VAR(__GLEW_ARB_texture_non_power_of_two) + +#endif /* GL_ARB_texture_non_power_of_two */ + +/* ------------------------ GL_ARB_texture_query_lod ----------------------- */ + +#ifndef GL_ARB_texture_query_lod +#define GL_ARB_texture_query_lod 1 + +#define GLEW_ARB_texture_query_lod GLEW_GET_VAR(__GLEW_ARB_texture_query_lod) + +#endif /* GL_ARB_texture_query_lod */ + +/* ------------------------ GL_ARB_texture_rectangle ----------------------- */ + +#ifndef GL_ARB_texture_rectangle +#define GL_ARB_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_ARB 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 +#define GL_SAMPLER_2D_RECT_ARB 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 + +#define GLEW_ARB_texture_rectangle GLEW_GET_VAR(__GLEW_ARB_texture_rectangle) + +#endif /* GL_ARB_texture_rectangle */ + +/* --------------------------- GL_ARB_texture_rg --------------------------- */ + +#ifndef GL_ARB_texture_rg +#define GL_ARB_texture_rg 1 + +#define GL_RED 0x1903 +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C + +#define GLEW_ARB_texture_rg GLEW_GET_VAR(__GLEW_ARB_texture_rg) + +#endif /* GL_ARB_texture_rg */ + +/* ----------------------- GL_ARB_texture_rgb10_a2ui ----------------------- */ + +#ifndef GL_ARB_texture_rgb10_a2ui +#define GL_ARB_texture_rgb10_a2ui 1 + +#define GL_RGB10_A2UI 0x906F + +#define GLEW_ARB_texture_rgb10_a2ui GLEW_GET_VAR(__GLEW_ARB_texture_rgb10_a2ui) + +#endif /* GL_ARB_texture_rgb10_a2ui */ + +/* ------------------------- GL_ARB_texture_storage ------------------------ */ + +#ifndef GL_ARB_texture_storage +#define GL_ARB_texture_storage 1 + +#define GL_ALPHA8_EXT 0x803C +#define GL_LUMINANCE8_EXT 0x8040 +#define GL_LUMINANCE8_ALPHA8_EXT 0x8045 +#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F + +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE1DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); + +#define glTexStorage1D GLEW_GET_FUN(__glewTexStorage1D) +#define glTexStorage2D GLEW_GET_FUN(__glewTexStorage2D) +#define glTexStorage3D GLEW_GET_FUN(__glewTexStorage3D) +#define glTextureStorage1DEXT GLEW_GET_FUN(__glewTextureStorage1DEXT) +#define glTextureStorage2DEXT GLEW_GET_FUN(__glewTextureStorage2DEXT) +#define glTextureStorage3DEXT GLEW_GET_FUN(__glewTextureStorage3DEXT) + +#define GLEW_ARB_texture_storage GLEW_GET_VAR(__GLEW_ARB_texture_storage) + +#endif /* GL_ARB_texture_storage */ + +/* ------------------------- GL_ARB_texture_swizzle ------------------------ */ + +#ifndef GL_ARB_texture_swizzle +#define GL_ARB_texture_swizzle 1 + +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 + +#define GLEW_ARB_texture_swizzle GLEW_GET_VAR(__GLEW_ARB_texture_swizzle) + +#endif /* GL_ARB_texture_swizzle */ + +/* --------------------------- GL_ARB_timer_query -------------------------- */ + +#ifndef GL_ARB_timer_query +#define GL_ARB_timer_query 1 + +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 + +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VPROC) (GLuint id, GLenum pname, GLint64* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VPROC) (GLuint id, GLenum pname, GLuint64* params); +typedef void (GLAPIENTRY * PFNGLQUERYCOUNTERPROC) (GLuint id, GLenum target); + +#define glGetQueryObjecti64v GLEW_GET_FUN(__glewGetQueryObjecti64v) +#define glGetQueryObjectui64v GLEW_GET_FUN(__glewGetQueryObjectui64v) +#define glQueryCounter GLEW_GET_FUN(__glewQueryCounter) + +#define GLEW_ARB_timer_query GLEW_GET_VAR(__GLEW_ARB_timer_query) + +#endif /* GL_ARB_timer_query */ + +/* ----------------------- GL_ARB_transform_feedback2 ---------------------- */ + +#ifndef GL_ARB_transform_feedback2 +#define GL_ARB_transform_feedback2 1 + +#define GL_TRANSFORM_FEEDBACK 0x8E22 +#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23 +#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24 +#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25 + +typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKPROC) (GLenum mode, GLuint id); +typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSPROC) (GLsizei n, GLuint* ids); +typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKPROC) (void); +typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKPROC) (void); + +#define glBindTransformFeedback GLEW_GET_FUN(__glewBindTransformFeedback) +#define glDeleteTransformFeedbacks GLEW_GET_FUN(__glewDeleteTransformFeedbacks) +#define glDrawTransformFeedback GLEW_GET_FUN(__glewDrawTransformFeedback) +#define glGenTransformFeedbacks GLEW_GET_FUN(__glewGenTransformFeedbacks) +#define glIsTransformFeedback GLEW_GET_FUN(__glewIsTransformFeedback) +#define glPauseTransformFeedback GLEW_GET_FUN(__glewPauseTransformFeedback) +#define glResumeTransformFeedback GLEW_GET_FUN(__glewResumeTransformFeedback) + +#define GLEW_ARB_transform_feedback2 GLEW_GET_VAR(__GLEW_ARB_transform_feedback2) + +#endif /* GL_ARB_transform_feedback2 */ + +/* ----------------------- GL_ARB_transform_feedback3 ---------------------- */ + +#ifndef GL_ARB_transform_feedback3 +#define GL_ARB_transform_feedback3 1 + +#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70 +#define GL_MAX_VERTEX_STREAMS 0x8E71 + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYINDEXEDPROC) (GLenum target, GLuint index, GLuint id); +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) (GLenum mode, GLuint id, GLuint stream); +typedef void (GLAPIENTRY * PFNGLENDQUERYINDEXEDPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLGETQUERYINDEXEDIVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params); + +#define glBeginQueryIndexed GLEW_GET_FUN(__glewBeginQueryIndexed) +#define glDrawTransformFeedbackStream GLEW_GET_FUN(__glewDrawTransformFeedbackStream) +#define glEndQueryIndexed GLEW_GET_FUN(__glewEndQueryIndexed) +#define glGetQueryIndexediv GLEW_GET_FUN(__glewGetQueryIndexediv) + +#define GLEW_ARB_transform_feedback3 GLEW_GET_VAR(__GLEW_ARB_transform_feedback3) + +#endif /* GL_ARB_transform_feedback3 */ + +/* ------------------ GL_ARB_transform_feedback_instanced ------------------ */ + +#ifndef GL_ARB_transform_feedback_instanced +#define GL_ARB_transform_feedback_instanced 1 + +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC) (GLenum mode, GLuint id, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC) (GLenum mode, GLuint id, GLuint stream, GLsizei primcount); + +#define glDrawTransformFeedbackInstanced GLEW_GET_FUN(__glewDrawTransformFeedbackInstanced) +#define glDrawTransformFeedbackStreamInstanced GLEW_GET_FUN(__glewDrawTransformFeedbackStreamInstanced) + +#define GLEW_ARB_transform_feedback_instanced GLEW_GET_VAR(__GLEW_ARB_transform_feedback_instanced) + +#endif /* GL_ARB_transform_feedback_instanced */ + +/* ------------------------ GL_ARB_transpose_matrix ------------------------ */ + +#ifndef GL_ARB_transpose_matrix +#define GL_ARB_transpose_matrix 1 + +#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 + +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); + +#define glLoadTransposeMatrixdARB GLEW_GET_FUN(__glewLoadTransposeMatrixdARB) +#define glLoadTransposeMatrixfARB GLEW_GET_FUN(__glewLoadTransposeMatrixfARB) +#define glMultTransposeMatrixdARB GLEW_GET_FUN(__glewMultTransposeMatrixdARB) +#define glMultTransposeMatrixfARB GLEW_GET_FUN(__glewMultTransposeMatrixfARB) + +#define GLEW_ARB_transpose_matrix GLEW_GET_VAR(__GLEW_ARB_transpose_matrix) + +#endif /* GL_ARB_transpose_matrix */ + +/* ---------------------- GL_ARB_uniform_buffer_object --------------------- */ + +#ifndef GL_ARB_uniform_buffer_object +#define GL_ARB_uniform_buffer_object 1 + +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF + +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, char* uniformBlockName); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKIVPROC) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMNAMEPROC) (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, char* uniformName); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMSIVPROC) (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint* data); +typedef GLuint (GLAPIENTRY * PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const char* uniformBlockName); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMINDICESPROC) (GLuint program, GLsizei uniformCount, const char** uniformNames, GLuint* uniformIndices); +typedef void (GLAPIENTRY * PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); + +#define glBindBufferBase GLEW_GET_FUN(__glewBindBufferBase) +#define glBindBufferRange GLEW_GET_FUN(__glewBindBufferRange) +#define glGetActiveUniformBlockName GLEW_GET_FUN(__glewGetActiveUniformBlockName) +#define glGetActiveUniformBlockiv GLEW_GET_FUN(__glewGetActiveUniformBlockiv) +#define glGetActiveUniformName GLEW_GET_FUN(__glewGetActiveUniformName) +#define glGetActiveUniformsiv GLEW_GET_FUN(__glewGetActiveUniformsiv) +#define glGetIntegeri_v GLEW_GET_FUN(__glewGetIntegeri_v) +#define glGetUniformBlockIndex GLEW_GET_FUN(__glewGetUniformBlockIndex) +#define glGetUniformIndices GLEW_GET_FUN(__glewGetUniformIndices) +#define glUniformBlockBinding GLEW_GET_FUN(__glewUniformBlockBinding) + +#define GLEW_ARB_uniform_buffer_object GLEW_GET_VAR(__GLEW_ARB_uniform_buffer_object) + +#endif /* GL_ARB_uniform_buffer_object */ + +/* ------------------------ GL_ARB_vertex_array_bgra ----------------------- */ + +#ifndef GL_ARB_vertex_array_bgra +#define GL_ARB_vertex_array_bgra 1 + +#define GL_BGRA 0x80E1 + +#define GLEW_ARB_vertex_array_bgra GLEW_GET_VAR(__GLEW_ARB_vertex_array_bgra) + +#endif /* GL_ARB_vertex_array_bgra */ + +/* ----------------------- GL_ARB_vertex_array_object ---------------------- */ + +#ifndef GL_ARB_vertex_array_object +#define GL_ARB_vertex_array_object 1 + +#define GL_VERTEX_ARRAY_BINDING 0x85B5 + +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYPROC) (GLuint array); + +#define glBindVertexArray GLEW_GET_FUN(__glewBindVertexArray) +#define glDeleteVertexArrays GLEW_GET_FUN(__glewDeleteVertexArrays) +#define glGenVertexArrays GLEW_GET_FUN(__glewGenVertexArrays) +#define glIsVertexArray GLEW_GET_FUN(__glewIsVertexArray) + +#define GLEW_ARB_vertex_array_object GLEW_GET_VAR(__GLEW_ARB_vertex_array_object) + +#endif /* GL_ARB_vertex_array_object */ + +/* ----------------------- GL_ARB_vertex_attrib_64bit ---------------------- */ + +#ifndef GL_ARB_vertex_attrib_64bit +#define GL_ARB_vertex_attrib_64bit 1 + +#define GL_DOUBLE_MAT2 0x8F46 +#define GL_DOUBLE_MAT3 0x8F47 +#define GL_DOUBLE_MAT4 0x8F48 +#define GL_DOUBLE_VEC2 0x8FFC +#define GL_DOUBLE_VEC3 0x8FFD +#define GL_DOUBLE_VEC4 0x8FFE + +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLDVPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer); + +#define glGetVertexAttribLdv GLEW_GET_FUN(__glewGetVertexAttribLdv) +#define glVertexAttribL1d GLEW_GET_FUN(__glewVertexAttribL1d) +#define glVertexAttribL1dv GLEW_GET_FUN(__glewVertexAttribL1dv) +#define glVertexAttribL2d GLEW_GET_FUN(__glewVertexAttribL2d) +#define glVertexAttribL2dv GLEW_GET_FUN(__glewVertexAttribL2dv) +#define glVertexAttribL3d GLEW_GET_FUN(__glewVertexAttribL3d) +#define glVertexAttribL3dv GLEW_GET_FUN(__glewVertexAttribL3dv) +#define glVertexAttribL4d GLEW_GET_FUN(__glewVertexAttribL4d) +#define glVertexAttribL4dv GLEW_GET_FUN(__glewVertexAttribL4dv) +#define glVertexAttribLPointer GLEW_GET_FUN(__glewVertexAttribLPointer) + +#define GLEW_ARB_vertex_attrib_64bit GLEW_GET_VAR(__GLEW_ARB_vertex_attrib_64bit) + +#endif /* GL_ARB_vertex_attrib_64bit */ + +/* -------------------------- GL_ARB_vertex_blend -------------------------- */ + +#ifndef GL_ARB_vertex_blend +#define GL_ARB_vertex_blend 1 + +#define GL_MODELVIEW0_ARB 0x1700 +#define GL_MODELVIEW1_ARB 0x850A +#define GL_MAX_VERTEX_UNITS_ARB 0x86A4 +#define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5 +#define GL_WEIGHT_SUM_UNITY_ARB 0x86A6 +#define GL_VERTEX_BLEND_ARB 0x86A7 +#define GL_CURRENT_WEIGHT_ARB 0x86A8 +#define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9 +#define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA +#define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB +#define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC +#define GL_WEIGHT_ARRAY_ARB 0x86AD +#define GL_MODELVIEW2_ARB 0x8722 +#define GL_MODELVIEW3_ARB 0x8723 +#define GL_MODELVIEW4_ARB 0x8724 +#define GL_MODELVIEW5_ARB 0x8725 +#define GL_MODELVIEW6_ARB 0x8726 +#define GL_MODELVIEW7_ARB 0x8727 +#define GL_MODELVIEW8_ARB 0x8728 +#define GL_MODELVIEW9_ARB 0x8729 +#define GL_MODELVIEW10_ARB 0x872A +#define GL_MODELVIEW11_ARB 0x872B +#define GL_MODELVIEW12_ARB 0x872C +#define GL_MODELVIEW13_ARB 0x872D +#define GL_MODELVIEW14_ARB 0x872E +#define GL_MODELVIEW15_ARB 0x872F +#define GL_MODELVIEW16_ARB 0x8730 +#define GL_MODELVIEW17_ARB 0x8731 +#define GL_MODELVIEW18_ARB 0x8732 +#define GL_MODELVIEW19_ARB 0x8733 +#define GL_MODELVIEW20_ARB 0x8734 +#define GL_MODELVIEW21_ARB 0x8735 +#define GL_MODELVIEW22_ARB 0x8736 +#define GL_MODELVIEW23_ARB 0x8737 +#define GL_MODELVIEW24_ARB 0x8738 +#define GL_MODELVIEW25_ARB 0x8739 +#define GL_MODELVIEW26_ARB 0x873A +#define GL_MODELVIEW27_ARB 0x873B +#define GL_MODELVIEW28_ARB 0x873C +#define GL_MODELVIEW29_ARB 0x873D +#define GL_MODELVIEW30_ARB 0x873E +#define GL_MODELVIEW31_ARB 0x873F + +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDARBPROC) (GLint count); +typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLWEIGHTBVARBPROC) (GLint size, GLbyte *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTDVARBPROC) (GLint size, GLdouble *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTFVARBPROC) (GLint size, GLfloat *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTIVARBPROC) (GLint size, GLint *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTSVARBPROC) (GLint size, GLshort *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUBVARBPROC) (GLint size, GLubyte *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUIVARBPROC) (GLint size, GLuint *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUSVARBPROC) (GLint size, GLushort *weights); + +#define glVertexBlendARB GLEW_GET_FUN(__glewVertexBlendARB) +#define glWeightPointerARB GLEW_GET_FUN(__glewWeightPointerARB) +#define glWeightbvARB GLEW_GET_FUN(__glewWeightbvARB) +#define glWeightdvARB GLEW_GET_FUN(__glewWeightdvARB) +#define glWeightfvARB GLEW_GET_FUN(__glewWeightfvARB) +#define glWeightivARB GLEW_GET_FUN(__glewWeightivARB) +#define glWeightsvARB GLEW_GET_FUN(__glewWeightsvARB) +#define glWeightubvARB GLEW_GET_FUN(__glewWeightubvARB) +#define glWeightuivARB GLEW_GET_FUN(__glewWeightuivARB) +#define glWeightusvARB GLEW_GET_FUN(__glewWeightusvARB) + +#define GLEW_ARB_vertex_blend GLEW_GET_VAR(__GLEW_ARB_vertex_blend) + +#endif /* GL_ARB_vertex_blend */ + +/* ---------------------- GL_ARB_vertex_buffer_object ---------------------- */ + +#ifndef GL_ARB_vertex_buffer_object +#define GL_ARB_vertex_buffer_object 1 + +#define GL_BUFFER_SIZE_ARB 0x8764 +#define GL_BUFFER_USAGE_ARB 0x8765 +#define GL_ARRAY_BUFFER_ARB 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 +#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F +#define GL_READ_ONLY_ARB 0x88B8 +#define GL_WRITE_ONLY_ARB 0x88B9 +#define GL_READ_WRITE_ARB 0x88BA +#define GL_BUFFER_ACCESS_ARB 0x88BB +#define GL_BUFFER_MAPPED_ARB 0x88BC +#define GL_BUFFER_MAP_POINTER_ARB 0x88BD +#define GL_STREAM_DRAW_ARB 0x88E0 +#define GL_STREAM_READ_ARB 0x88E1 +#define GL_STREAM_COPY_ARB 0x88E2 +#define GL_STATIC_DRAW_ARB 0x88E4 +#define GL_STATIC_READ_ARB 0x88E5 +#define GL_STATIC_COPY_ARB 0x88E6 +#define GL_DYNAMIC_DRAW_ARB 0x88E8 +#define GL_DYNAMIC_READ_ARB 0x88E9 +#define GL_DYNAMIC_COPY_ARB 0x88EA + +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; + +typedef void (GLAPIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid* data); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERARBPROC) (GLuint buffer); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERARBPROC) (GLenum target); + +#define glBindBufferARB GLEW_GET_FUN(__glewBindBufferARB) +#define glBufferDataARB GLEW_GET_FUN(__glewBufferDataARB) +#define glBufferSubDataARB GLEW_GET_FUN(__glewBufferSubDataARB) +#define glDeleteBuffersARB GLEW_GET_FUN(__glewDeleteBuffersARB) +#define glGenBuffersARB GLEW_GET_FUN(__glewGenBuffersARB) +#define glGetBufferParameterivARB GLEW_GET_FUN(__glewGetBufferParameterivARB) +#define glGetBufferPointervARB GLEW_GET_FUN(__glewGetBufferPointervARB) +#define glGetBufferSubDataARB GLEW_GET_FUN(__glewGetBufferSubDataARB) +#define glIsBufferARB GLEW_GET_FUN(__glewIsBufferARB) +#define glMapBufferARB GLEW_GET_FUN(__glewMapBufferARB) +#define glUnmapBufferARB GLEW_GET_FUN(__glewUnmapBufferARB) + +#define GLEW_ARB_vertex_buffer_object GLEW_GET_VAR(__GLEW_ARB_vertex_buffer_object) + +#endif /* GL_ARB_vertex_buffer_object */ + +/* ------------------------- GL_ARB_vertex_program ------------------------- */ + +#ifndef GL_ARB_vertex_program +#define GL_ARB_vertex_program 1 + +#define GL_COLOR_SUM_ARB 0x8458 +#define GL_VERTEX_PROGRAM_ARB 0x8620 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 +#define GL_PROGRAM_LENGTH_ARB 0x8627 +#define GL_PROGRAM_STRING_ARB 0x8628 +#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E +#define GL_MAX_PROGRAM_MATRICES_ARB 0x862F +#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 +#define GL_CURRENT_MATRIX_ARB 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 +#define GL_PROGRAM_ERROR_POSITION_ARB 0x864B +#define GL_PROGRAM_BINDING_ARB 0x8677 +#define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A +#define GL_PROGRAM_ERROR_STRING_ARB 0x8874 +#define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 +#define GL_PROGRAM_FORMAT_ARB 0x8876 +#define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 +#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 +#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 +#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 +#define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 +#define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 +#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 +#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 +#define GL_PROGRAM_PARAMETERS_ARB 0x88A8 +#define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 +#define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA +#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB +#define GL_PROGRAM_ATTRIBS_ARB 0x88AC +#define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD +#define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE +#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF +#define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 +#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 +#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 +#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 +#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 +#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 +#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 +#define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 +#define GL_MATRIX0_ARB 0x88C0 +#define GL_MATRIX1_ARB 0x88C1 +#define GL_MATRIX2_ARB 0x88C2 +#define GL_MATRIX3_ARB 0x88C3 +#define GL_MATRIX4_ARB 0x88C4 +#define GL_MATRIX5_ARB 0x88C5 +#define GL_MATRIX6_ARB 0x88C6 +#define GL_MATRIX7_ARB 0x88C7 +#define GL_MATRIX8_ARB 0x88C8 +#define GL_MATRIX9_ARB 0x88C9 +#define GL_MATRIX10_ARB 0x88CA +#define GL_MATRIX11_ARB 0x88CB +#define GL_MATRIX12_ARB 0x88CC +#define GL_MATRIX13_ARB 0x88CD +#define GL_MATRIX14_ARB 0x88CE +#define GL_MATRIX15_ARB 0x88CF +#define GL_MATRIX16_ARB 0x88D0 +#define GL_MATRIX17_ARB 0x88D1 +#define GL_MATRIX18_ARB 0x88D2 +#define GL_MATRIX19_ARB 0x88D3 +#define GL_MATRIX20_ARB 0x88D4 +#define GL_MATRIX21_ARB 0x88D5 +#define GL_MATRIX22_ARB 0x88D6 +#define GL_MATRIX23_ARB 0x88D7 +#define GL_MATRIX24_ARB 0x88D8 +#define GL_MATRIX25_ARB 0x88D9 +#define GL_MATRIX26_ARB 0x88DA +#define GL_MATRIX27_ARB 0x88DB +#define GL_MATRIX28_ARB 0x88DC +#define GL_MATRIX29_ARB 0x88DD +#define GL_MATRIX30_ARB 0x88DE +#define GL_MATRIX31_ARB 0x88DF + +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint* programs); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint* programs); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, void* string); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const void* string); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer); + +#define glBindProgramARB GLEW_GET_FUN(__glewBindProgramARB) +#define glDeleteProgramsARB GLEW_GET_FUN(__glewDeleteProgramsARB) +#define glDisableVertexAttribArrayARB GLEW_GET_FUN(__glewDisableVertexAttribArrayARB) +#define glEnableVertexAttribArrayARB GLEW_GET_FUN(__glewEnableVertexAttribArrayARB) +#define glGenProgramsARB GLEW_GET_FUN(__glewGenProgramsARB) +#define glGetProgramEnvParameterdvARB GLEW_GET_FUN(__glewGetProgramEnvParameterdvARB) +#define glGetProgramEnvParameterfvARB GLEW_GET_FUN(__glewGetProgramEnvParameterfvARB) +#define glGetProgramLocalParameterdvARB GLEW_GET_FUN(__glewGetProgramLocalParameterdvARB) +#define glGetProgramLocalParameterfvARB GLEW_GET_FUN(__glewGetProgramLocalParameterfvARB) +#define glGetProgramStringARB GLEW_GET_FUN(__glewGetProgramStringARB) +#define glGetProgramivARB GLEW_GET_FUN(__glewGetProgramivARB) +#define glGetVertexAttribPointervARB GLEW_GET_FUN(__glewGetVertexAttribPointervARB) +#define glGetVertexAttribdvARB GLEW_GET_FUN(__glewGetVertexAttribdvARB) +#define glGetVertexAttribfvARB GLEW_GET_FUN(__glewGetVertexAttribfvARB) +#define glGetVertexAttribivARB GLEW_GET_FUN(__glewGetVertexAttribivARB) +#define glIsProgramARB GLEW_GET_FUN(__glewIsProgramARB) +#define glProgramEnvParameter4dARB GLEW_GET_FUN(__glewProgramEnvParameter4dARB) +#define glProgramEnvParameter4dvARB GLEW_GET_FUN(__glewProgramEnvParameter4dvARB) +#define glProgramEnvParameter4fARB GLEW_GET_FUN(__glewProgramEnvParameter4fARB) +#define glProgramEnvParameter4fvARB GLEW_GET_FUN(__glewProgramEnvParameter4fvARB) +#define glProgramLocalParameter4dARB GLEW_GET_FUN(__glewProgramLocalParameter4dARB) +#define glProgramLocalParameter4dvARB GLEW_GET_FUN(__glewProgramLocalParameter4dvARB) +#define glProgramLocalParameter4fARB GLEW_GET_FUN(__glewProgramLocalParameter4fARB) +#define glProgramLocalParameter4fvARB GLEW_GET_FUN(__glewProgramLocalParameter4fvARB) +#define glProgramStringARB GLEW_GET_FUN(__glewProgramStringARB) +#define glVertexAttrib1dARB GLEW_GET_FUN(__glewVertexAttrib1dARB) +#define glVertexAttrib1dvARB GLEW_GET_FUN(__glewVertexAttrib1dvARB) +#define glVertexAttrib1fARB GLEW_GET_FUN(__glewVertexAttrib1fARB) +#define glVertexAttrib1fvARB GLEW_GET_FUN(__glewVertexAttrib1fvARB) +#define glVertexAttrib1sARB GLEW_GET_FUN(__glewVertexAttrib1sARB) +#define glVertexAttrib1svARB GLEW_GET_FUN(__glewVertexAttrib1svARB) +#define glVertexAttrib2dARB GLEW_GET_FUN(__glewVertexAttrib2dARB) +#define glVertexAttrib2dvARB GLEW_GET_FUN(__glewVertexAttrib2dvARB) +#define glVertexAttrib2fARB GLEW_GET_FUN(__glewVertexAttrib2fARB) +#define glVertexAttrib2fvARB GLEW_GET_FUN(__glewVertexAttrib2fvARB) +#define glVertexAttrib2sARB GLEW_GET_FUN(__glewVertexAttrib2sARB) +#define glVertexAttrib2svARB GLEW_GET_FUN(__glewVertexAttrib2svARB) +#define glVertexAttrib3dARB GLEW_GET_FUN(__glewVertexAttrib3dARB) +#define glVertexAttrib3dvARB GLEW_GET_FUN(__glewVertexAttrib3dvARB) +#define glVertexAttrib3fARB GLEW_GET_FUN(__glewVertexAttrib3fARB) +#define glVertexAttrib3fvARB GLEW_GET_FUN(__glewVertexAttrib3fvARB) +#define glVertexAttrib3sARB GLEW_GET_FUN(__glewVertexAttrib3sARB) +#define glVertexAttrib3svARB GLEW_GET_FUN(__glewVertexAttrib3svARB) +#define glVertexAttrib4NbvARB GLEW_GET_FUN(__glewVertexAttrib4NbvARB) +#define glVertexAttrib4NivARB GLEW_GET_FUN(__glewVertexAttrib4NivARB) +#define glVertexAttrib4NsvARB GLEW_GET_FUN(__glewVertexAttrib4NsvARB) +#define glVertexAttrib4NubARB GLEW_GET_FUN(__glewVertexAttrib4NubARB) +#define glVertexAttrib4NubvARB GLEW_GET_FUN(__glewVertexAttrib4NubvARB) +#define glVertexAttrib4NuivARB GLEW_GET_FUN(__glewVertexAttrib4NuivARB) +#define glVertexAttrib4NusvARB GLEW_GET_FUN(__glewVertexAttrib4NusvARB) +#define glVertexAttrib4bvARB GLEW_GET_FUN(__glewVertexAttrib4bvARB) +#define glVertexAttrib4dARB GLEW_GET_FUN(__glewVertexAttrib4dARB) +#define glVertexAttrib4dvARB GLEW_GET_FUN(__glewVertexAttrib4dvARB) +#define glVertexAttrib4fARB GLEW_GET_FUN(__glewVertexAttrib4fARB) +#define glVertexAttrib4fvARB GLEW_GET_FUN(__glewVertexAttrib4fvARB) +#define glVertexAttrib4ivARB GLEW_GET_FUN(__glewVertexAttrib4ivARB) +#define glVertexAttrib4sARB GLEW_GET_FUN(__glewVertexAttrib4sARB) +#define glVertexAttrib4svARB GLEW_GET_FUN(__glewVertexAttrib4svARB) +#define glVertexAttrib4ubvARB GLEW_GET_FUN(__glewVertexAttrib4ubvARB) +#define glVertexAttrib4uivARB GLEW_GET_FUN(__glewVertexAttrib4uivARB) +#define glVertexAttrib4usvARB GLEW_GET_FUN(__glewVertexAttrib4usvARB) +#define glVertexAttribPointerARB GLEW_GET_FUN(__glewVertexAttribPointerARB) + +#define GLEW_ARB_vertex_program GLEW_GET_VAR(__GLEW_ARB_vertex_program) + +#endif /* GL_ARB_vertex_program */ + +/* -------------------------- GL_ARB_vertex_shader ------------------------- */ + +#ifndef GL_ARB_vertex_shader +#define GL_ARB_vertex_shader 1 + +#define GL_VERTEX_SHADER_ARB 0x8B31 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A +#define GL_MAX_VARYING_FLOATS_ARB 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D +#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 +#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A + +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB* name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); + +#define glBindAttribLocationARB GLEW_GET_FUN(__glewBindAttribLocationARB) +#define glGetActiveAttribARB GLEW_GET_FUN(__glewGetActiveAttribARB) +#define glGetAttribLocationARB GLEW_GET_FUN(__glewGetAttribLocationARB) + +#define GLEW_ARB_vertex_shader GLEW_GET_VAR(__GLEW_ARB_vertex_shader) + +#endif /* GL_ARB_vertex_shader */ + +/* ------------------- GL_ARB_vertex_type_2_10_10_10_rev ------------------- */ + +#ifndef GL_ARB_vertex_type_2_10_10_10_rev +#define GL_ARB_vertex_type_2_10_10_10_rev 1 + +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_INT_2_10_10_10_REV 0x8D9F + +typedef void (GLAPIENTRY * PFNGLCOLORP3UIPROC) (GLenum type, GLuint color); +typedef void (GLAPIENTRY * PFNGLCOLORP3UIVPROC) (GLenum type, const GLuint* color); +typedef void (GLAPIENTRY * PFNGLCOLORP4UIPROC) (GLenum type, GLuint color); +typedef void (GLAPIENTRY * PFNGLCOLORP4UIVPROC) (GLenum type, const GLuint* color); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIPROC) (GLenum texture, GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIPROC) (GLenum texture, GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIPROC) (GLenum texture, GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIPROC) (GLenum texture, GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLNORMALP3UIPROC) (GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLNORMALP3UIVPROC) (GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIPROC) (GLenum type, GLuint color); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIVPROC) (GLenum type, const GLuint* color); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIPROC) (GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIVPROC) (GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIPROC) (GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIVPROC) (GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIPROC) (GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIVPROC) (GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIPROC) (GLenum type, GLuint coords); +typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIVPROC) (GLenum type, const GLuint* coords); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXP2UIPROC) (GLenum type, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXP2UIVPROC) (GLenum type, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXP3UIPROC) (GLenum type, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXP3UIVPROC) (GLenum type, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLVERTEXP4UIPROC) (GLenum type, GLuint value); +typedef void (GLAPIENTRY * PFNGLVERTEXP4UIVPROC) (GLenum type, const GLuint* value); + +#define glColorP3ui GLEW_GET_FUN(__glewColorP3ui) +#define glColorP3uiv GLEW_GET_FUN(__glewColorP3uiv) +#define glColorP4ui GLEW_GET_FUN(__glewColorP4ui) +#define glColorP4uiv GLEW_GET_FUN(__glewColorP4uiv) +#define glMultiTexCoordP1ui GLEW_GET_FUN(__glewMultiTexCoordP1ui) +#define glMultiTexCoordP1uiv GLEW_GET_FUN(__glewMultiTexCoordP1uiv) +#define glMultiTexCoordP2ui GLEW_GET_FUN(__glewMultiTexCoordP2ui) +#define glMultiTexCoordP2uiv GLEW_GET_FUN(__glewMultiTexCoordP2uiv) +#define glMultiTexCoordP3ui GLEW_GET_FUN(__glewMultiTexCoordP3ui) +#define glMultiTexCoordP3uiv GLEW_GET_FUN(__glewMultiTexCoordP3uiv) +#define glMultiTexCoordP4ui GLEW_GET_FUN(__glewMultiTexCoordP4ui) +#define glMultiTexCoordP4uiv GLEW_GET_FUN(__glewMultiTexCoordP4uiv) +#define glNormalP3ui GLEW_GET_FUN(__glewNormalP3ui) +#define glNormalP3uiv GLEW_GET_FUN(__glewNormalP3uiv) +#define glSecondaryColorP3ui GLEW_GET_FUN(__glewSecondaryColorP3ui) +#define glSecondaryColorP3uiv GLEW_GET_FUN(__glewSecondaryColorP3uiv) +#define glTexCoordP1ui GLEW_GET_FUN(__glewTexCoordP1ui) +#define glTexCoordP1uiv GLEW_GET_FUN(__glewTexCoordP1uiv) +#define glTexCoordP2ui GLEW_GET_FUN(__glewTexCoordP2ui) +#define glTexCoordP2uiv GLEW_GET_FUN(__glewTexCoordP2uiv) +#define glTexCoordP3ui GLEW_GET_FUN(__glewTexCoordP3ui) +#define glTexCoordP3uiv GLEW_GET_FUN(__glewTexCoordP3uiv) +#define glTexCoordP4ui GLEW_GET_FUN(__glewTexCoordP4ui) +#define glTexCoordP4uiv GLEW_GET_FUN(__glewTexCoordP4uiv) +#define glVertexAttribP1ui GLEW_GET_FUN(__glewVertexAttribP1ui) +#define glVertexAttribP1uiv GLEW_GET_FUN(__glewVertexAttribP1uiv) +#define glVertexAttribP2ui GLEW_GET_FUN(__glewVertexAttribP2ui) +#define glVertexAttribP2uiv GLEW_GET_FUN(__glewVertexAttribP2uiv) +#define glVertexAttribP3ui GLEW_GET_FUN(__glewVertexAttribP3ui) +#define glVertexAttribP3uiv GLEW_GET_FUN(__glewVertexAttribP3uiv) +#define glVertexAttribP4ui GLEW_GET_FUN(__glewVertexAttribP4ui) +#define glVertexAttribP4uiv GLEW_GET_FUN(__glewVertexAttribP4uiv) +#define glVertexP2ui GLEW_GET_FUN(__glewVertexP2ui) +#define glVertexP2uiv GLEW_GET_FUN(__glewVertexP2uiv) +#define glVertexP3ui GLEW_GET_FUN(__glewVertexP3ui) +#define glVertexP3uiv GLEW_GET_FUN(__glewVertexP3uiv) +#define glVertexP4ui GLEW_GET_FUN(__glewVertexP4ui) +#define glVertexP4uiv GLEW_GET_FUN(__glewVertexP4uiv) + +#define GLEW_ARB_vertex_type_2_10_10_10_rev GLEW_GET_VAR(__GLEW_ARB_vertex_type_2_10_10_10_rev) + +#endif /* GL_ARB_vertex_type_2_10_10_10_rev */ + +/* ------------------------- GL_ARB_viewport_array ------------------------- */ + +#ifndef GL_ARB_viewport_array +#define GL_ARB_viewport_array 1 + +#define GL_DEPTH_RANGE 0x0B70 +#define GL_VIEWPORT 0x0BA2 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_MAX_VIEWPORTS 0x825B +#define GL_VIEWPORT_SUBPIXEL_BITS 0x825C +#define GL_VIEWPORT_BOUNDS_RANGE 0x825D +#define GL_LAYER_PROVOKING_VERTEX 0x825E +#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F +#define GL_UNDEFINED_VERTEX 0x8260 +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F + +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEARRAYVPROC) (GLuint first, GLsizei count, const GLclampd * v); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEINDEXEDPROC) (GLuint index, GLclampd n, GLclampd f); +typedef void (GLAPIENTRY * PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble* data); +typedef void (GLAPIENTRY * PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat* data); +typedef void (GLAPIENTRY * PFNGLSCISSORARRAYVPROC) (GLuint first, GLsizei count, const GLint * v); +typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDPROC) (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDVPROC) (GLuint index, const GLint * v); +typedef void (GLAPIENTRY * PFNGLVIEWPORTARRAYVPROC) (GLuint first, GLsizei count, const GLfloat * v); +typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFVPROC) (GLuint index, const GLfloat * v); + +#define glDepthRangeArrayv GLEW_GET_FUN(__glewDepthRangeArrayv) +#define glDepthRangeIndexed GLEW_GET_FUN(__glewDepthRangeIndexed) +#define glGetDoublei_v GLEW_GET_FUN(__glewGetDoublei_v) +#define glGetFloati_v GLEW_GET_FUN(__glewGetFloati_v) +#define glScissorArrayv GLEW_GET_FUN(__glewScissorArrayv) +#define glScissorIndexed GLEW_GET_FUN(__glewScissorIndexed) +#define glScissorIndexedv GLEW_GET_FUN(__glewScissorIndexedv) +#define glViewportArrayv GLEW_GET_FUN(__glewViewportArrayv) +#define glViewportIndexedf GLEW_GET_FUN(__glewViewportIndexedf) +#define glViewportIndexedfv GLEW_GET_FUN(__glewViewportIndexedfv) + +#define GLEW_ARB_viewport_array GLEW_GET_VAR(__GLEW_ARB_viewport_array) + +#endif /* GL_ARB_viewport_array */ + +/* --------------------------- GL_ARB_window_pos --------------------------- */ + +#ifndef GL_ARB_window_pos +#define GL_ARB_window_pos 1 + +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVARBPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVARBPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVARBPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVARBPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVARBPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVARBPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVARBPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p); + +#define glWindowPos2dARB GLEW_GET_FUN(__glewWindowPos2dARB) +#define glWindowPos2dvARB GLEW_GET_FUN(__glewWindowPos2dvARB) +#define glWindowPos2fARB GLEW_GET_FUN(__glewWindowPos2fARB) +#define glWindowPos2fvARB GLEW_GET_FUN(__glewWindowPos2fvARB) +#define glWindowPos2iARB GLEW_GET_FUN(__glewWindowPos2iARB) +#define glWindowPos2ivARB GLEW_GET_FUN(__glewWindowPos2ivARB) +#define glWindowPos2sARB GLEW_GET_FUN(__glewWindowPos2sARB) +#define glWindowPos2svARB GLEW_GET_FUN(__glewWindowPos2svARB) +#define glWindowPos3dARB GLEW_GET_FUN(__glewWindowPos3dARB) +#define glWindowPos3dvARB GLEW_GET_FUN(__glewWindowPos3dvARB) +#define glWindowPos3fARB GLEW_GET_FUN(__glewWindowPos3fARB) +#define glWindowPos3fvARB GLEW_GET_FUN(__glewWindowPos3fvARB) +#define glWindowPos3iARB GLEW_GET_FUN(__glewWindowPos3iARB) +#define glWindowPos3ivARB GLEW_GET_FUN(__glewWindowPos3ivARB) +#define glWindowPos3sARB GLEW_GET_FUN(__glewWindowPos3sARB) +#define glWindowPos3svARB GLEW_GET_FUN(__glewWindowPos3svARB) + +#define GLEW_ARB_window_pos GLEW_GET_VAR(__GLEW_ARB_window_pos) + +#endif /* GL_ARB_window_pos */ + +/* ------------------------- GL_ATIX_point_sprites ------------------------- */ + +#ifndef GL_ATIX_point_sprites +#define GL_ATIX_point_sprites 1 + +#define GL_TEXTURE_POINT_MODE_ATIX 0x60B0 +#define GL_TEXTURE_POINT_ONE_COORD_ATIX 0x60B1 +#define GL_TEXTURE_POINT_SPRITE_ATIX 0x60B2 +#define GL_POINT_SPRITE_CULL_MODE_ATIX 0x60B3 +#define GL_POINT_SPRITE_CULL_CENTER_ATIX 0x60B4 +#define GL_POINT_SPRITE_CULL_CLIP_ATIX 0x60B5 + +#define GLEW_ATIX_point_sprites GLEW_GET_VAR(__GLEW_ATIX_point_sprites) + +#endif /* GL_ATIX_point_sprites */ + +/* ---------------------- GL_ATIX_texture_env_combine3 --------------------- */ + +#ifndef GL_ATIX_texture_env_combine3 +#define GL_ATIX_texture_env_combine3 1 + +#define GL_MODULATE_ADD_ATIX 0x8744 +#define GL_MODULATE_SIGNED_ADD_ATIX 0x8745 +#define GL_MODULATE_SUBTRACT_ATIX 0x8746 + +#define GLEW_ATIX_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATIX_texture_env_combine3) + +#endif /* GL_ATIX_texture_env_combine3 */ + +/* ----------------------- GL_ATIX_texture_env_route ----------------------- */ + +#ifndef GL_ATIX_texture_env_route +#define GL_ATIX_texture_env_route 1 + +#define GL_SECONDARY_COLOR_ATIX 0x8747 +#define GL_TEXTURE_OUTPUT_RGB_ATIX 0x8748 +#define GL_TEXTURE_OUTPUT_ALPHA_ATIX 0x8749 + +#define GLEW_ATIX_texture_env_route GLEW_GET_VAR(__GLEW_ATIX_texture_env_route) + +#endif /* GL_ATIX_texture_env_route */ + +/* ---------------- GL_ATIX_vertex_shader_output_point_size ---------------- */ + +#ifndef GL_ATIX_vertex_shader_output_point_size +#define GL_ATIX_vertex_shader_output_point_size 1 + +#define GL_OUTPUT_POINT_SIZE_ATIX 0x610E + +#define GLEW_ATIX_vertex_shader_output_point_size GLEW_GET_VAR(__GLEW_ATIX_vertex_shader_output_point_size) + +#endif /* GL_ATIX_vertex_shader_output_point_size */ + +/* -------------------------- GL_ATI_draw_buffers -------------------------- */ + +#ifndef GL_ATI_draw_buffers +#define GL_ATI_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_ATI 0x8824 +#define GL_DRAW_BUFFER0_ATI 0x8825 +#define GL_DRAW_BUFFER1_ATI 0x8826 +#define GL_DRAW_BUFFER2_ATI 0x8827 +#define GL_DRAW_BUFFER3_ATI 0x8828 +#define GL_DRAW_BUFFER4_ATI 0x8829 +#define GL_DRAW_BUFFER5_ATI 0x882A +#define GL_DRAW_BUFFER6_ATI 0x882B +#define GL_DRAW_BUFFER7_ATI 0x882C +#define GL_DRAW_BUFFER8_ATI 0x882D +#define GL_DRAW_BUFFER9_ATI 0x882E +#define GL_DRAW_BUFFER10_ATI 0x882F +#define GL_DRAW_BUFFER11_ATI 0x8830 +#define GL_DRAW_BUFFER12_ATI 0x8831 +#define GL_DRAW_BUFFER13_ATI 0x8832 +#define GL_DRAW_BUFFER14_ATI 0x8833 +#define GL_DRAW_BUFFER15_ATI 0x8834 + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersATI GLEW_GET_FUN(__glewDrawBuffersATI) + +#define GLEW_ATI_draw_buffers GLEW_GET_VAR(__GLEW_ATI_draw_buffers) + +#endif /* GL_ATI_draw_buffers */ + +/* -------------------------- GL_ATI_element_array ------------------------- */ + +#ifndef GL_ATI_element_array +#define GL_ATI_element_array 1 + +#define GL_ELEMENT_ARRAY_ATI 0x8768 +#define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769 +#define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count); +typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERATIPROC) (GLenum type, const void* pointer); + +#define glDrawElementArrayATI GLEW_GET_FUN(__glewDrawElementArrayATI) +#define glDrawRangeElementArrayATI GLEW_GET_FUN(__glewDrawRangeElementArrayATI) +#define glElementPointerATI GLEW_GET_FUN(__glewElementPointerATI) + +#define GLEW_ATI_element_array GLEW_GET_VAR(__GLEW_ATI_element_array) + +#endif /* GL_ATI_element_array */ + +/* ------------------------- GL_ATI_envmap_bumpmap ------------------------- */ + +#ifndef GL_ATI_envmap_bumpmap +#define GL_ATI_envmap_bumpmap 1 + +#define GL_BUMP_ROT_MATRIX_ATI 0x8775 +#define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776 +#define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777 +#define GL_BUMP_TEX_UNITS_ATI 0x8778 +#define GL_DUDV_ATI 0x8779 +#define GL_DU8DV8_ATI 0x877A +#define GL_BUMP_ENVMAP_ATI 0x877B +#define GL_BUMP_TARGET_ATI 0x877C + +typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); +typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); +typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); +typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); + +#define glGetTexBumpParameterfvATI GLEW_GET_FUN(__glewGetTexBumpParameterfvATI) +#define glGetTexBumpParameterivATI GLEW_GET_FUN(__glewGetTexBumpParameterivATI) +#define glTexBumpParameterfvATI GLEW_GET_FUN(__glewTexBumpParameterfvATI) +#define glTexBumpParameterivATI GLEW_GET_FUN(__glewTexBumpParameterivATI) + +#define GLEW_ATI_envmap_bumpmap GLEW_GET_VAR(__GLEW_ATI_envmap_bumpmap) + +#endif /* GL_ATI_envmap_bumpmap */ + +/* ------------------------- GL_ATI_fragment_shader ------------------------ */ + +#ifndef GL_ATI_fragment_shader +#define GL_ATI_fragment_shader 1 + +#define GL_RED_BIT_ATI 0x00000001 +#define GL_2X_BIT_ATI 0x00000001 +#define GL_4X_BIT_ATI 0x00000002 +#define GL_GREEN_BIT_ATI 0x00000002 +#define GL_COMP_BIT_ATI 0x00000002 +#define GL_BLUE_BIT_ATI 0x00000004 +#define GL_8X_BIT_ATI 0x00000004 +#define GL_NEGATE_BIT_ATI 0x00000004 +#define GL_BIAS_BIT_ATI 0x00000008 +#define GL_HALF_BIT_ATI 0x00000008 +#define GL_QUARTER_BIT_ATI 0x00000010 +#define GL_EIGHTH_BIT_ATI 0x00000020 +#define GL_SATURATE_BIT_ATI 0x00000040 +#define GL_FRAGMENT_SHADER_ATI 0x8920 +#define GL_REG_0_ATI 0x8921 +#define GL_REG_1_ATI 0x8922 +#define GL_REG_2_ATI 0x8923 +#define GL_REG_3_ATI 0x8924 +#define GL_REG_4_ATI 0x8925 +#define GL_REG_5_ATI 0x8926 +#define GL_CON_0_ATI 0x8941 +#define GL_CON_1_ATI 0x8942 +#define GL_CON_2_ATI 0x8943 +#define GL_CON_3_ATI 0x8944 +#define GL_CON_4_ATI 0x8945 +#define GL_CON_5_ATI 0x8946 +#define GL_CON_6_ATI 0x8947 +#define GL_CON_7_ATI 0x8948 +#define GL_MOV_ATI 0x8961 +#define GL_ADD_ATI 0x8963 +#define GL_MUL_ATI 0x8964 +#define GL_SUB_ATI 0x8965 +#define GL_DOT3_ATI 0x8966 +#define GL_DOT4_ATI 0x8967 +#define GL_MAD_ATI 0x8968 +#define GL_LERP_ATI 0x8969 +#define GL_CND_ATI 0x896A +#define GL_CND0_ATI 0x896B +#define GL_DOT2_ADD_ATI 0x896C +#define GL_SECONDARY_INTERPOLATOR_ATI 0x896D +#define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E +#define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F +#define GL_NUM_PASSES_ATI 0x8970 +#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971 +#define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972 +#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973 +#define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974 +#define GL_COLOR_ALPHA_PAIRING_ATI 0x8975 +#define GL_SWIZZLE_STR_ATI 0x8976 +#define GL_SWIZZLE_STQ_ATI 0x8977 +#define GL_SWIZZLE_STR_DR_ATI 0x8978 +#define GL_SWIZZLE_STQ_DQ_ATI 0x8979 +#define GL_SWIZZLE_STRQ_ATI 0x897A +#define GL_SWIZZLE_STRQ_DQ_ATI 0x897B + +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (GLAPIENTRY * PFNGLBEGINFRAGMENTSHADERATIPROC) (void); +typedef void (GLAPIENTRY * PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (GLAPIENTRY * PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENDFRAGMENTSHADERATIPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range); +typedef void (GLAPIENTRY * PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle); +typedef void (GLAPIENTRY * PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle); +typedef void (GLAPIENTRY * PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat* value); + +#define glAlphaFragmentOp1ATI GLEW_GET_FUN(__glewAlphaFragmentOp1ATI) +#define glAlphaFragmentOp2ATI GLEW_GET_FUN(__glewAlphaFragmentOp2ATI) +#define glAlphaFragmentOp3ATI GLEW_GET_FUN(__glewAlphaFragmentOp3ATI) +#define glBeginFragmentShaderATI GLEW_GET_FUN(__glewBeginFragmentShaderATI) +#define glBindFragmentShaderATI GLEW_GET_FUN(__glewBindFragmentShaderATI) +#define glColorFragmentOp1ATI GLEW_GET_FUN(__glewColorFragmentOp1ATI) +#define glColorFragmentOp2ATI GLEW_GET_FUN(__glewColorFragmentOp2ATI) +#define glColorFragmentOp3ATI GLEW_GET_FUN(__glewColorFragmentOp3ATI) +#define glDeleteFragmentShaderATI GLEW_GET_FUN(__glewDeleteFragmentShaderATI) +#define glEndFragmentShaderATI GLEW_GET_FUN(__glewEndFragmentShaderATI) +#define glGenFragmentShadersATI GLEW_GET_FUN(__glewGenFragmentShadersATI) +#define glPassTexCoordATI GLEW_GET_FUN(__glewPassTexCoordATI) +#define glSampleMapATI GLEW_GET_FUN(__glewSampleMapATI) +#define glSetFragmentShaderConstantATI GLEW_GET_FUN(__glewSetFragmentShaderConstantATI) + +#define GLEW_ATI_fragment_shader GLEW_GET_VAR(__GLEW_ATI_fragment_shader) + +#endif /* GL_ATI_fragment_shader */ + +/* ------------------------ GL_ATI_map_object_buffer ----------------------- */ + +#ifndef GL_ATI_map_object_buffer +#define GL_ATI_map_object_buffer 1 + +typedef void* (GLAPIENTRY * PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer); + +#define glMapObjectBufferATI GLEW_GET_FUN(__glewMapObjectBufferATI) +#define glUnmapObjectBufferATI GLEW_GET_FUN(__glewUnmapObjectBufferATI) + +#define GLEW_ATI_map_object_buffer GLEW_GET_VAR(__GLEW_ATI_map_object_buffer) + +#endif /* GL_ATI_map_object_buffer */ + +/* ----------------------------- GL_ATI_meminfo ---------------------------- */ + +#ifndef GL_ATI_meminfo +#define GL_ATI_meminfo 1 + +#define GL_VBO_FREE_MEMORY_ATI 0x87FB +#define GL_TEXTURE_FREE_MEMORY_ATI 0x87FC +#define GL_RENDERBUFFER_FREE_MEMORY_ATI 0x87FD + +#define GLEW_ATI_meminfo GLEW_GET_VAR(__GLEW_ATI_meminfo) + +#endif /* GL_ATI_meminfo */ + +/* -------------------------- GL_ATI_pn_triangles -------------------------- */ + +#ifndef GL_ATI_pn_triangles +#define GL_ATI_pn_triangles 1 + +#define GL_PN_TRIANGLES_ATI 0x87F0 +#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1 +#define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2 +#define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3 +#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4 +#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5 +#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6 +#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7 +#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8 + +typedef void (GLAPIENTRY * PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param); + +#define glPNTrianglesfATI GLEW_GET_FUN(__glewPNTrianglesfATI) +#define glPNTrianglesiATI GLEW_GET_FUN(__glewPNTrianglesiATI) + +#define GLEW_ATI_pn_triangles GLEW_GET_VAR(__GLEW_ATI_pn_triangles) + +#endif /* GL_ATI_pn_triangles */ + +/* ------------------------ GL_ATI_separate_stencil ------------------------ */ + +#ifndef GL_ATI_separate_stencil +#define GL_ATI_separate_stencil 1 + +#define GL_STENCIL_BACK_FUNC_ATI 0x8800 +#define GL_STENCIL_BACK_FAIL_ATI 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803 + +typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + +#define glStencilFuncSeparateATI GLEW_GET_FUN(__glewStencilFuncSeparateATI) +#define glStencilOpSeparateATI GLEW_GET_FUN(__glewStencilOpSeparateATI) + +#define GLEW_ATI_separate_stencil GLEW_GET_VAR(__GLEW_ATI_separate_stencil) + +#endif /* GL_ATI_separate_stencil */ + +/* ----------------------- GL_ATI_shader_texture_lod ----------------------- */ + +#ifndef GL_ATI_shader_texture_lod +#define GL_ATI_shader_texture_lod 1 + +#define GLEW_ATI_shader_texture_lod GLEW_GET_VAR(__GLEW_ATI_shader_texture_lod) + +#endif /* GL_ATI_shader_texture_lod */ + +/* ---------------------- GL_ATI_text_fragment_shader ---------------------- */ + +#ifndef GL_ATI_text_fragment_shader +#define GL_ATI_text_fragment_shader 1 + +#define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200 + +#define GLEW_ATI_text_fragment_shader GLEW_GET_VAR(__GLEW_ATI_text_fragment_shader) + +#endif /* GL_ATI_text_fragment_shader */ + +/* --------------------- GL_ATI_texture_compression_3dc -------------------- */ + +#ifndef GL_ATI_texture_compression_3dc +#define GL_ATI_texture_compression_3dc 1 + +#define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837 + +#define GLEW_ATI_texture_compression_3dc GLEW_GET_VAR(__GLEW_ATI_texture_compression_3dc) + +#endif /* GL_ATI_texture_compression_3dc */ + +/* ---------------------- GL_ATI_texture_env_combine3 ---------------------- */ + +#ifndef GL_ATI_texture_env_combine3 +#define GL_ATI_texture_env_combine3 1 + +#define GL_MODULATE_ADD_ATI 0x8744 +#define GL_MODULATE_SIGNED_ADD_ATI 0x8745 +#define GL_MODULATE_SUBTRACT_ATI 0x8746 + +#define GLEW_ATI_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATI_texture_env_combine3) + +#endif /* GL_ATI_texture_env_combine3 */ + +/* -------------------------- GL_ATI_texture_float ------------------------- */ + +#ifndef GL_ATI_texture_float +#define GL_ATI_texture_float 1 + +#define GL_RGBA_FLOAT32_ATI 0x8814 +#define GL_RGB_FLOAT32_ATI 0x8815 +#define GL_ALPHA_FLOAT32_ATI 0x8816 +#define GL_INTENSITY_FLOAT32_ATI 0x8817 +#define GL_LUMINANCE_FLOAT32_ATI 0x8818 +#define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819 +#define GL_RGBA_FLOAT16_ATI 0x881A +#define GL_RGB_FLOAT16_ATI 0x881B +#define GL_ALPHA_FLOAT16_ATI 0x881C +#define GL_INTENSITY_FLOAT16_ATI 0x881D +#define GL_LUMINANCE_FLOAT16_ATI 0x881E +#define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F + +#define GLEW_ATI_texture_float GLEW_GET_VAR(__GLEW_ATI_texture_float) + +#endif /* GL_ATI_texture_float */ + +/* ----------------------- GL_ATI_texture_mirror_once ---------------------- */ + +#ifndef GL_ATI_texture_mirror_once +#define GL_ATI_texture_mirror_once 1 + +#define GL_MIRROR_CLAMP_ATI 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743 + +#define GLEW_ATI_texture_mirror_once GLEW_GET_VAR(__GLEW_ATI_texture_mirror_once) + +#endif /* GL_ATI_texture_mirror_once */ + +/* ----------------------- GL_ATI_vertex_array_object ---------------------- */ + +#ifndef GL_ATI_vertex_array_object +#define GL_ATI_vertex_array_object 1 + +#define GL_STATIC_ATI 0x8760 +#define GL_DYNAMIC_ATI 0x8761 +#define GL_PRESERVE_ATI 0x8762 +#define GL_DISCARD_ATI 0x8763 +#define GL_OBJECT_BUFFER_SIZE_ATI 0x8764 +#define GL_OBJECT_BUFFER_USAGE_ATI 0x8765 +#define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766 +#define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767 + +typedef void (GLAPIENTRY * PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); +typedef void (GLAPIENTRY * PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer); +typedef GLuint (GLAPIENTRY * PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const void* pointer, GLenum usage); +typedef void (GLAPIENTRY * PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve); +typedef void (GLAPIENTRY * PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); + +#define glArrayObjectATI GLEW_GET_FUN(__glewArrayObjectATI) +#define glFreeObjectBufferATI GLEW_GET_FUN(__glewFreeObjectBufferATI) +#define glGetArrayObjectfvATI GLEW_GET_FUN(__glewGetArrayObjectfvATI) +#define glGetArrayObjectivATI GLEW_GET_FUN(__glewGetArrayObjectivATI) +#define glGetObjectBufferfvATI GLEW_GET_FUN(__glewGetObjectBufferfvATI) +#define glGetObjectBufferivATI GLEW_GET_FUN(__glewGetObjectBufferivATI) +#define glGetVariantArrayObjectfvATI GLEW_GET_FUN(__glewGetVariantArrayObjectfvATI) +#define glGetVariantArrayObjectivATI GLEW_GET_FUN(__glewGetVariantArrayObjectivATI) +#define glIsObjectBufferATI GLEW_GET_FUN(__glewIsObjectBufferATI) +#define glNewObjectBufferATI GLEW_GET_FUN(__glewNewObjectBufferATI) +#define glUpdateObjectBufferATI GLEW_GET_FUN(__glewUpdateObjectBufferATI) +#define glVariantArrayObjectATI GLEW_GET_FUN(__glewVariantArrayObjectATI) + +#define GLEW_ATI_vertex_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_array_object) + +#endif /* GL_ATI_vertex_array_object */ + +/* ------------------- GL_ATI_vertex_attrib_array_object ------------------- */ + +#ifndef GL_ATI_vertex_attrib_array_object +#define GL_ATI_vertex_attrib_array_object 1 + +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset); + +#define glGetVertexAttribArrayObjectfvATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectfvATI) +#define glGetVertexAttribArrayObjectivATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectivATI) +#define glVertexAttribArrayObjectATI GLEW_GET_FUN(__glewVertexAttribArrayObjectATI) + +#define GLEW_ATI_vertex_attrib_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_attrib_array_object) + +#endif /* GL_ATI_vertex_attrib_array_object */ + +/* ------------------------- GL_ATI_vertex_streams ------------------------- */ + +#ifndef GL_ATI_vertex_streams +#define GL_ATI_vertex_streams 1 + +#define GL_MAX_VERTEX_STREAMS_ATI 0x876B +#define GL_VERTEX_SOURCE_ATI 0x876C +#define GL_VERTEX_STREAM0_ATI 0x876D +#define GL_VERTEX_STREAM1_ATI 0x876E +#define GL_VERTEX_STREAM2_ATI 0x876F +#define GL_VERTEX_STREAM3_ATI 0x8770 +#define GL_VERTEX_STREAM4_ATI 0x8771 +#define GL_VERTEX_STREAM5_ATI 0x8772 +#define GL_VERTEX_STREAM6_ATI 0x8773 +#define GL_VERTEX_STREAM7_ATI 0x8774 + +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *v); + +#define glClientActiveVertexStreamATI GLEW_GET_FUN(__glewClientActiveVertexStreamATI) +#define glNormalStream3bATI GLEW_GET_FUN(__glewNormalStream3bATI) +#define glNormalStream3bvATI GLEW_GET_FUN(__glewNormalStream3bvATI) +#define glNormalStream3dATI GLEW_GET_FUN(__glewNormalStream3dATI) +#define glNormalStream3dvATI GLEW_GET_FUN(__glewNormalStream3dvATI) +#define glNormalStream3fATI GLEW_GET_FUN(__glewNormalStream3fATI) +#define glNormalStream3fvATI GLEW_GET_FUN(__glewNormalStream3fvATI) +#define glNormalStream3iATI GLEW_GET_FUN(__glewNormalStream3iATI) +#define glNormalStream3ivATI GLEW_GET_FUN(__glewNormalStream3ivATI) +#define glNormalStream3sATI GLEW_GET_FUN(__glewNormalStream3sATI) +#define glNormalStream3svATI GLEW_GET_FUN(__glewNormalStream3svATI) +#define glVertexBlendEnvfATI GLEW_GET_FUN(__glewVertexBlendEnvfATI) +#define glVertexBlendEnviATI GLEW_GET_FUN(__glewVertexBlendEnviATI) +#define glVertexStream2dATI GLEW_GET_FUN(__glewVertexStream2dATI) +#define glVertexStream2dvATI GLEW_GET_FUN(__glewVertexStream2dvATI) +#define glVertexStream2fATI GLEW_GET_FUN(__glewVertexStream2fATI) +#define glVertexStream2fvATI GLEW_GET_FUN(__glewVertexStream2fvATI) +#define glVertexStream2iATI GLEW_GET_FUN(__glewVertexStream2iATI) +#define glVertexStream2ivATI GLEW_GET_FUN(__glewVertexStream2ivATI) +#define glVertexStream2sATI GLEW_GET_FUN(__glewVertexStream2sATI) +#define glVertexStream2svATI GLEW_GET_FUN(__glewVertexStream2svATI) +#define glVertexStream3dATI GLEW_GET_FUN(__glewVertexStream3dATI) +#define glVertexStream3dvATI GLEW_GET_FUN(__glewVertexStream3dvATI) +#define glVertexStream3fATI GLEW_GET_FUN(__glewVertexStream3fATI) +#define glVertexStream3fvATI GLEW_GET_FUN(__glewVertexStream3fvATI) +#define glVertexStream3iATI GLEW_GET_FUN(__glewVertexStream3iATI) +#define glVertexStream3ivATI GLEW_GET_FUN(__glewVertexStream3ivATI) +#define glVertexStream3sATI GLEW_GET_FUN(__glewVertexStream3sATI) +#define glVertexStream3svATI GLEW_GET_FUN(__glewVertexStream3svATI) +#define glVertexStream4dATI GLEW_GET_FUN(__glewVertexStream4dATI) +#define glVertexStream4dvATI GLEW_GET_FUN(__glewVertexStream4dvATI) +#define glVertexStream4fATI GLEW_GET_FUN(__glewVertexStream4fATI) +#define glVertexStream4fvATI GLEW_GET_FUN(__glewVertexStream4fvATI) +#define glVertexStream4iATI GLEW_GET_FUN(__glewVertexStream4iATI) +#define glVertexStream4ivATI GLEW_GET_FUN(__glewVertexStream4ivATI) +#define glVertexStream4sATI GLEW_GET_FUN(__glewVertexStream4sATI) +#define glVertexStream4svATI GLEW_GET_FUN(__glewVertexStream4svATI) + +#define GLEW_ATI_vertex_streams GLEW_GET_VAR(__GLEW_ATI_vertex_streams) + +#endif /* GL_ATI_vertex_streams */ + +/* --------------------------- GL_EXT_422_pixels --------------------------- */ + +#ifndef GL_EXT_422_pixels +#define GL_EXT_422_pixels 1 + +#define GL_422_EXT 0x80CC +#define GL_422_REV_EXT 0x80CD +#define GL_422_AVERAGE_EXT 0x80CE +#define GL_422_REV_AVERAGE_EXT 0x80CF + +#define GLEW_EXT_422_pixels GLEW_GET_VAR(__GLEW_EXT_422_pixels) + +#endif /* GL_EXT_422_pixels */ + +/* ---------------------------- GL_EXT_Cg_shader --------------------------- */ + +#ifndef GL_EXT_Cg_shader +#define GL_EXT_Cg_shader 1 + +#define GL_CG_VERTEX_SHADER_EXT 0x890E +#define GL_CG_FRAGMENT_SHADER_EXT 0x890F + +#define GLEW_EXT_Cg_shader GLEW_GET_VAR(__GLEW_EXT_Cg_shader) + +#endif /* GL_EXT_Cg_shader */ + +/* ------------------------------ GL_EXT_abgr ------------------------------ */ + +#ifndef GL_EXT_abgr +#define GL_EXT_abgr 1 + +#define GL_ABGR_EXT 0x8000 + +#define GLEW_EXT_abgr GLEW_GET_VAR(__GLEW_EXT_abgr) + +#endif /* GL_EXT_abgr */ + +/* ------------------------------ GL_EXT_bgra ------------------------------ */ + +#ifndef GL_EXT_bgra +#define GL_EXT_bgra 1 + +#define GL_BGR_EXT 0x80E0 +#define GL_BGRA_EXT 0x80E1 + +#define GLEW_EXT_bgra GLEW_GET_VAR(__GLEW_EXT_bgra) + +#endif /* GL_EXT_bgra */ + +/* ------------------------ GL_EXT_bindable_uniform ------------------------ */ + +#ifndef GL_EXT_bindable_uniform +#define GL_EXT_bindable_uniform 1 + +#define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT 0x8DE2 +#define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT 0x8DE3 +#define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT 0x8DE4 +#define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT 0x8DED +#define GL_UNIFORM_BUFFER_EXT 0x8DEE +#define GL_UNIFORM_BUFFER_BINDING_EXT 0x8DEF + +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint program, GLint location); +typedef GLintptr (GLAPIENTRY * PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program, GLint location); +typedef void (GLAPIENTRY * PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint location, GLuint buffer); + +#define glGetUniformBufferSizeEXT GLEW_GET_FUN(__glewGetUniformBufferSizeEXT) +#define glGetUniformOffsetEXT GLEW_GET_FUN(__glewGetUniformOffsetEXT) +#define glUniformBufferEXT GLEW_GET_FUN(__glewUniformBufferEXT) + +#define GLEW_EXT_bindable_uniform GLEW_GET_VAR(__GLEW_EXT_bindable_uniform) + +#endif /* GL_EXT_bindable_uniform */ + +/* --------------------------- GL_EXT_blend_color -------------------------- */ + +#ifndef GL_EXT_blend_color +#define GL_EXT_blend_color 1 + +#define GL_CONSTANT_COLOR_EXT 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 +#define GL_CONSTANT_ALPHA_EXT 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 +#define GL_BLEND_COLOR_EXT 0x8005 + +typedef void (GLAPIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + +#define glBlendColorEXT GLEW_GET_FUN(__glewBlendColorEXT) + +#define GLEW_EXT_blend_color GLEW_GET_VAR(__GLEW_EXT_blend_color) + +#endif /* GL_EXT_blend_color */ + +/* --------------------- GL_EXT_blend_equation_separate -------------------- */ + +#ifndef GL_EXT_blend_equation_separate +#define GL_EXT_blend_equation_separate 1 + +#define GL_BLEND_EQUATION_RGB_EXT 0x8009 +#define GL_BLEND_EQUATION_ALPHA_EXT 0x883D + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); + +#define glBlendEquationSeparateEXT GLEW_GET_FUN(__glewBlendEquationSeparateEXT) + +#define GLEW_EXT_blend_equation_separate GLEW_GET_VAR(__GLEW_EXT_blend_equation_separate) + +#endif /* GL_EXT_blend_equation_separate */ + +/* ----------------------- GL_EXT_blend_func_separate ---------------------- */ + +#ifndef GL_EXT_blend_func_separate +#define GL_EXT_blend_func_separate 1 + +#define GL_BLEND_DST_RGB_EXT 0x80C8 +#define GL_BLEND_SRC_RGB_EXT 0x80C9 +#define GL_BLEND_DST_ALPHA_EXT 0x80CA +#define GL_BLEND_SRC_ALPHA_EXT 0x80CB + +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +#define glBlendFuncSeparateEXT GLEW_GET_FUN(__glewBlendFuncSeparateEXT) + +#define GLEW_EXT_blend_func_separate GLEW_GET_VAR(__GLEW_EXT_blend_func_separate) + +#endif /* GL_EXT_blend_func_separate */ + +/* ------------------------- GL_EXT_blend_logic_op ------------------------- */ + +#ifndef GL_EXT_blend_logic_op +#define GL_EXT_blend_logic_op 1 + +#define GLEW_EXT_blend_logic_op GLEW_GET_VAR(__GLEW_EXT_blend_logic_op) + +#endif /* GL_EXT_blend_logic_op */ + +/* -------------------------- GL_EXT_blend_minmax -------------------------- */ + +#ifndef GL_EXT_blend_minmax +#define GL_EXT_blend_minmax 1 + +#define GL_FUNC_ADD_EXT 0x8006 +#define GL_MIN_EXT 0x8007 +#define GL_MAX_EXT 0x8008 +#define GL_BLEND_EQUATION_EXT 0x8009 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); + +#define glBlendEquationEXT GLEW_GET_FUN(__glewBlendEquationEXT) + +#define GLEW_EXT_blend_minmax GLEW_GET_VAR(__GLEW_EXT_blend_minmax) + +#endif /* GL_EXT_blend_minmax */ + +/* ------------------------- GL_EXT_blend_subtract ------------------------- */ + +#ifndef GL_EXT_blend_subtract +#define GL_EXT_blend_subtract 1 + +#define GL_FUNC_SUBTRACT_EXT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B + +#define GLEW_EXT_blend_subtract GLEW_GET_VAR(__GLEW_EXT_blend_subtract) + +#endif /* GL_EXT_blend_subtract */ + +/* ------------------------ GL_EXT_clip_volume_hint ------------------------ */ + +#ifndef GL_EXT_clip_volume_hint +#define GL_EXT_clip_volume_hint 1 + +#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F0 + +#define GLEW_EXT_clip_volume_hint GLEW_GET_VAR(__GLEW_EXT_clip_volume_hint) + +#endif /* GL_EXT_clip_volume_hint */ + +/* ------------------------------ GL_EXT_cmyka ----------------------------- */ + +#ifndef GL_EXT_cmyka +#define GL_EXT_cmyka 1 + +#define GL_CMYK_EXT 0x800C +#define GL_CMYKA_EXT 0x800D +#define GL_PACK_CMYK_HINT_EXT 0x800E +#define GL_UNPACK_CMYK_HINT_EXT 0x800F + +#define GLEW_EXT_cmyka GLEW_GET_VAR(__GLEW_EXT_cmyka) + +#endif /* GL_EXT_cmyka */ + +/* ------------------------- GL_EXT_color_subtable ------------------------- */ + +#ifndef GL_EXT_color_subtable +#define GL_EXT_color_subtable 1 + +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + +#define glColorSubTableEXT GLEW_GET_FUN(__glewColorSubTableEXT) +#define glCopyColorSubTableEXT GLEW_GET_FUN(__glewCopyColorSubTableEXT) + +#define GLEW_EXT_color_subtable GLEW_GET_VAR(__GLEW_EXT_color_subtable) + +#endif /* GL_EXT_color_subtable */ + +/* ---------------------- GL_EXT_compiled_vertex_array --------------------- */ + +#ifndef GL_EXT_compiled_vertex_array +#define GL_EXT_compiled_vertex_array 1 + +#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 +#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 + +typedef void (GLAPIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void); + +#define glLockArraysEXT GLEW_GET_FUN(__glewLockArraysEXT) +#define glUnlockArraysEXT GLEW_GET_FUN(__glewUnlockArraysEXT) + +#define GLEW_EXT_compiled_vertex_array GLEW_GET_VAR(__GLEW_EXT_compiled_vertex_array) + +#endif /* GL_EXT_compiled_vertex_array */ + +/* --------------------------- GL_EXT_convolution -------------------------- */ + +#ifndef GL_EXT_convolution +#define GL_EXT_convolution 1 + +#define GL_CONVOLUTION_1D_EXT 0x8010 +#define GL_CONVOLUTION_2D_EXT 0x8011 +#define GL_SEPARABLE_2D_EXT 0x8012 +#define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 +#define GL_REDUCE_EXT 0x8016 +#define GL_CONVOLUTION_FORMAT_EXT 0x8017 +#define GL_CONVOLUTION_WIDTH_EXT 0x8018 +#define GL_CONVOLUTION_HEIGHT_EXT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 + +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void* image); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void* row, void* column, void* span); +typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column); + +#define glConvolutionFilter1DEXT GLEW_GET_FUN(__glewConvolutionFilter1DEXT) +#define glConvolutionFilter2DEXT GLEW_GET_FUN(__glewConvolutionFilter2DEXT) +#define glConvolutionParameterfEXT GLEW_GET_FUN(__glewConvolutionParameterfEXT) +#define glConvolutionParameterfvEXT GLEW_GET_FUN(__glewConvolutionParameterfvEXT) +#define glConvolutionParameteriEXT GLEW_GET_FUN(__glewConvolutionParameteriEXT) +#define glConvolutionParameterivEXT GLEW_GET_FUN(__glewConvolutionParameterivEXT) +#define glCopyConvolutionFilter1DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter1DEXT) +#define glCopyConvolutionFilter2DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter2DEXT) +#define glGetConvolutionFilterEXT GLEW_GET_FUN(__glewGetConvolutionFilterEXT) +#define glGetConvolutionParameterfvEXT GLEW_GET_FUN(__glewGetConvolutionParameterfvEXT) +#define glGetConvolutionParameterivEXT GLEW_GET_FUN(__glewGetConvolutionParameterivEXT) +#define glGetSeparableFilterEXT GLEW_GET_FUN(__glewGetSeparableFilterEXT) +#define glSeparableFilter2DEXT GLEW_GET_FUN(__glewSeparableFilter2DEXT) + +#define GLEW_EXT_convolution GLEW_GET_VAR(__GLEW_EXT_convolution) + +#endif /* GL_EXT_convolution */ + +/* ------------------------ GL_EXT_coordinate_frame ------------------------ */ + +#ifndef GL_EXT_coordinate_frame +#define GL_EXT_coordinate_frame 1 + +#define GL_TANGENT_ARRAY_EXT 0x8439 +#define GL_BINORMAL_ARRAY_EXT 0x843A +#define GL_CURRENT_TANGENT_EXT 0x843B +#define GL_CURRENT_BINORMAL_EXT 0x843C +#define GL_TANGENT_ARRAY_TYPE_EXT 0x843E +#define GL_TANGENT_ARRAY_STRIDE_EXT 0x843F +#define GL_BINORMAL_ARRAY_TYPE_EXT 0x8440 +#define GL_BINORMAL_ARRAY_STRIDE_EXT 0x8441 +#define GL_TANGENT_ARRAY_POINTER_EXT 0x8442 +#define GL_BINORMAL_ARRAY_POINTER_EXT 0x8443 +#define GL_MAP1_TANGENT_EXT 0x8444 +#define GL_MAP2_TANGENT_EXT 0x8445 +#define GL_MAP1_BINORMAL_EXT 0x8446 +#define GL_MAP2_BINORMAL_EXT 0x8447 + +typedef void (GLAPIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, void* pointer); +typedef void (GLAPIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, void* pointer); + +#define glBinormalPointerEXT GLEW_GET_FUN(__glewBinormalPointerEXT) +#define glTangentPointerEXT GLEW_GET_FUN(__glewTangentPointerEXT) + +#define GLEW_EXT_coordinate_frame GLEW_GET_VAR(__GLEW_EXT_coordinate_frame) + +#endif /* GL_EXT_coordinate_frame */ + +/* -------------------------- GL_EXT_copy_texture -------------------------- */ + +#ifndef GL_EXT_copy_texture +#define GL_EXT_copy_texture 1 + +typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +#define glCopyTexImage1DEXT GLEW_GET_FUN(__glewCopyTexImage1DEXT) +#define glCopyTexImage2DEXT GLEW_GET_FUN(__glewCopyTexImage2DEXT) +#define glCopyTexSubImage1DEXT GLEW_GET_FUN(__glewCopyTexSubImage1DEXT) +#define glCopyTexSubImage2DEXT GLEW_GET_FUN(__glewCopyTexSubImage2DEXT) +#define glCopyTexSubImage3DEXT GLEW_GET_FUN(__glewCopyTexSubImage3DEXT) + +#define GLEW_EXT_copy_texture GLEW_GET_VAR(__GLEW_EXT_copy_texture) + +#endif /* GL_EXT_copy_texture */ + +/* --------------------------- GL_EXT_cull_vertex -------------------------- */ + +#ifndef GL_EXT_cull_vertex +#define GL_EXT_cull_vertex 1 + +#define GL_CULL_VERTEX_EXT 0x81AA +#define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB +#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC + +typedef void (GLAPIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params); + +#define glCullParameterdvEXT GLEW_GET_FUN(__glewCullParameterdvEXT) +#define glCullParameterfvEXT GLEW_GET_FUN(__glewCullParameterfvEXT) + +#define GLEW_EXT_cull_vertex GLEW_GET_VAR(__GLEW_EXT_cull_vertex) + +#endif /* GL_EXT_cull_vertex */ + +/* ------------------------ GL_EXT_depth_bounds_test ----------------------- */ + +#ifndef GL_EXT_depth_bounds_test +#define GL_EXT_depth_bounds_test 1 + +#define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 +#define GL_DEPTH_BOUNDS_EXT 0x8891 + +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); + +#define glDepthBoundsEXT GLEW_GET_FUN(__glewDepthBoundsEXT) + +#define GLEW_EXT_depth_bounds_test GLEW_GET_VAR(__GLEW_EXT_depth_bounds_test) + +#endif /* GL_EXT_depth_bounds_test */ + +/* ----------------------- GL_EXT_direct_state_access ---------------------- */ + +#ifndef GL_EXT_direct_state_access +#define GL_EXT_direct_state_access 1 + +#define GL_PROGRAM_MATRIX_EXT 0x8E2D +#define GL_TRANSPOSE_PROGRAM_MATRIX_EXT 0x8E2E +#define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT 0x8E2F + +typedef void (GLAPIENTRY * PFNGLBINDMULTITEXTUREEXTPROC) (GLenum texunit, GLenum target, GLuint texture); +typedef GLenum (GLAPIENTRY * PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) (GLuint framebuffer, GLenum target); +typedef void (GLAPIENTRY * PFNGLCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array); +typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array); +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, const GLenum* bufs); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit, GLenum target); +typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, void* img); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, void* img); +typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void* pixels); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) (GLuint buffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) (GLuint buffer, GLenum pname, void** params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, void* data); +typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, void* string); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum target, GLuint index, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERVEXTPROC) (GLuint vaobj, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLvoid** param); +typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERVEXTPROC) (GLuint vaobj, GLenum pname, GLvoid** param); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPNAMEDBUFFEREXTPROC) (GLuint buffer, GLenum access); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access); +typedef void (GLAPIENTRY * PFNGLMATRIXFRUSTUMEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXORTHOEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); +typedef void (GLAPIENTRY * PFNGLMATRIXPOPEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXPUSHEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEDEXTPROC) (GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEFEXTPROC) (GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMULTITEXBUFFEREXTPROC) (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDPOINTEREXTPROC) (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* param); +typedef void (GLAPIENTRY * PFNGLMULTITEXRENDERBUFFEREXTPROC) (GLenum texunit, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const void* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data); +typedef void (GLAPIENTRY * PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum format, GLsizei len, const void* string); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIEXTPROC) (GLuint program, GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLfloat* param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* param); +typedef void (GLAPIENTRY * PFNGLTEXTURERENDERBUFFEREXTPROC) (GLuint texture, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYINDEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYNORMALOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); + +#define glBindMultiTextureEXT GLEW_GET_FUN(__glewBindMultiTextureEXT) +#define glCheckNamedFramebufferStatusEXT GLEW_GET_FUN(__glewCheckNamedFramebufferStatusEXT) +#define glClientAttribDefaultEXT GLEW_GET_FUN(__glewClientAttribDefaultEXT) +#define glCompressedMultiTexImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage1DEXT) +#define glCompressedMultiTexImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage2DEXT) +#define glCompressedMultiTexImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage3DEXT) +#define glCompressedMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage1DEXT) +#define glCompressedMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage2DEXT) +#define glCompressedMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage3DEXT) +#define glCompressedTextureImage1DEXT GLEW_GET_FUN(__glewCompressedTextureImage1DEXT) +#define glCompressedTextureImage2DEXT GLEW_GET_FUN(__glewCompressedTextureImage2DEXT) +#define glCompressedTextureImage3DEXT GLEW_GET_FUN(__glewCompressedTextureImage3DEXT) +#define glCompressedTextureSubImage1DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage1DEXT) +#define glCompressedTextureSubImage2DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage2DEXT) +#define glCompressedTextureSubImage3DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage3DEXT) +#define glCopyMultiTexImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexImage1DEXT) +#define glCopyMultiTexImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexImage2DEXT) +#define glCopyMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage1DEXT) +#define glCopyMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage2DEXT) +#define glCopyMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage3DEXT) +#define glCopyTextureImage1DEXT GLEW_GET_FUN(__glewCopyTextureImage1DEXT) +#define glCopyTextureImage2DEXT GLEW_GET_FUN(__glewCopyTextureImage2DEXT) +#define glCopyTextureSubImage1DEXT GLEW_GET_FUN(__glewCopyTextureSubImage1DEXT) +#define glCopyTextureSubImage2DEXT GLEW_GET_FUN(__glewCopyTextureSubImage2DEXT) +#define glCopyTextureSubImage3DEXT GLEW_GET_FUN(__glewCopyTextureSubImage3DEXT) +#define glDisableClientStateIndexedEXT GLEW_GET_FUN(__glewDisableClientStateIndexedEXT) +#define glDisableClientStateiEXT GLEW_GET_FUN(__glewDisableClientStateiEXT) +#define glDisableVertexArrayAttribEXT GLEW_GET_FUN(__glewDisableVertexArrayAttribEXT) +#define glDisableVertexArrayEXT GLEW_GET_FUN(__glewDisableVertexArrayEXT) +#define glEnableClientStateIndexedEXT GLEW_GET_FUN(__glewEnableClientStateIndexedEXT) +#define glEnableClientStateiEXT GLEW_GET_FUN(__glewEnableClientStateiEXT) +#define glEnableVertexArrayAttribEXT GLEW_GET_FUN(__glewEnableVertexArrayAttribEXT) +#define glEnableVertexArrayEXT GLEW_GET_FUN(__glewEnableVertexArrayEXT) +#define glFlushMappedNamedBufferRangeEXT GLEW_GET_FUN(__glewFlushMappedNamedBufferRangeEXT) +#define glFramebufferDrawBufferEXT GLEW_GET_FUN(__glewFramebufferDrawBufferEXT) +#define glFramebufferDrawBuffersEXT GLEW_GET_FUN(__glewFramebufferDrawBuffersEXT) +#define glFramebufferReadBufferEXT GLEW_GET_FUN(__glewFramebufferReadBufferEXT) +#define glGenerateMultiTexMipmapEXT GLEW_GET_FUN(__glewGenerateMultiTexMipmapEXT) +#define glGenerateTextureMipmapEXT GLEW_GET_FUN(__glewGenerateTextureMipmapEXT) +#define glGetCompressedMultiTexImageEXT GLEW_GET_FUN(__glewGetCompressedMultiTexImageEXT) +#define glGetCompressedTextureImageEXT GLEW_GET_FUN(__glewGetCompressedTextureImageEXT) +#define glGetDoubleIndexedvEXT GLEW_GET_FUN(__glewGetDoubleIndexedvEXT) +#define glGetDoublei_vEXT GLEW_GET_FUN(__glewGetDoublei_vEXT) +#define glGetFloatIndexedvEXT GLEW_GET_FUN(__glewGetFloatIndexedvEXT) +#define glGetFloati_vEXT GLEW_GET_FUN(__glewGetFloati_vEXT) +#define glGetFramebufferParameterivEXT GLEW_GET_FUN(__glewGetFramebufferParameterivEXT) +#define glGetMultiTexEnvfvEXT GLEW_GET_FUN(__glewGetMultiTexEnvfvEXT) +#define glGetMultiTexEnvivEXT GLEW_GET_FUN(__glewGetMultiTexEnvivEXT) +#define glGetMultiTexGendvEXT GLEW_GET_FUN(__glewGetMultiTexGendvEXT) +#define glGetMultiTexGenfvEXT GLEW_GET_FUN(__glewGetMultiTexGenfvEXT) +#define glGetMultiTexGenivEXT GLEW_GET_FUN(__glewGetMultiTexGenivEXT) +#define glGetMultiTexImageEXT GLEW_GET_FUN(__glewGetMultiTexImageEXT) +#define glGetMultiTexLevelParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterfvEXT) +#define glGetMultiTexLevelParameterivEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterivEXT) +#define glGetMultiTexParameterIivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIivEXT) +#define glGetMultiTexParameterIuivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIuivEXT) +#define glGetMultiTexParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexParameterfvEXT) +#define glGetMultiTexParameterivEXT GLEW_GET_FUN(__glewGetMultiTexParameterivEXT) +#define glGetNamedBufferParameterivEXT GLEW_GET_FUN(__glewGetNamedBufferParameterivEXT) +#define glGetNamedBufferPointervEXT GLEW_GET_FUN(__glewGetNamedBufferPointervEXT) +#define glGetNamedBufferSubDataEXT GLEW_GET_FUN(__glewGetNamedBufferSubDataEXT) +#define glGetNamedFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetNamedFramebufferAttachmentParameterivEXT) +#define glGetNamedProgramLocalParameterIivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIivEXT) +#define glGetNamedProgramLocalParameterIuivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIuivEXT) +#define glGetNamedProgramLocalParameterdvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterdvEXT) +#define glGetNamedProgramLocalParameterfvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterfvEXT) +#define glGetNamedProgramStringEXT GLEW_GET_FUN(__glewGetNamedProgramStringEXT) +#define glGetNamedProgramivEXT GLEW_GET_FUN(__glewGetNamedProgramivEXT) +#define glGetNamedRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetNamedRenderbufferParameterivEXT) +#define glGetPointerIndexedvEXT GLEW_GET_FUN(__glewGetPointerIndexedvEXT) +#define glGetPointeri_vEXT GLEW_GET_FUN(__glewGetPointeri_vEXT) +#define glGetTextureImageEXT GLEW_GET_FUN(__glewGetTextureImageEXT) +#define glGetTextureLevelParameterfvEXT GLEW_GET_FUN(__glewGetTextureLevelParameterfvEXT) +#define glGetTextureLevelParameterivEXT GLEW_GET_FUN(__glewGetTextureLevelParameterivEXT) +#define glGetTextureParameterIivEXT GLEW_GET_FUN(__glewGetTextureParameterIivEXT) +#define glGetTextureParameterIuivEXT GLEW_GET_FUN(__glewGetTextureParameterIuivEXT) +#define glGetTextureParameterfvEXT GLEW_GET_FUN(__glewGetTextureParameterfvEXT) +#define glGetTextureParameterivEXT GLEW_GET_FUN(__glewGetTextureParameterivEXT) +#define glGetVertexArrayIntegeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayIntegeri_vEXT) +#define glGetVertexArrayIntegervEXT GLEW_GET_FUN(__glewGetVertexArrayIntegervEXT) +#define glGetVertexArrayPointeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayPointeri_vEXT) +#define glGetVertexArrayPointervEXT GLEW_GET_FUN(__glewGetVertexArrayPointervEXT) +#define glMapNamedBufferEXT GLEW_GET_FUN(__glewMapNamedBufferEXT) +#define glMapNamedBufferRangeEXT GLEW_GET_FUN(__glewMapNamedBufferRangeEXT) +#define glMatrixFrustumEXT GLEW_GET_FUN(__glewMatrixFrustumEXT) +#define glMatrixLoadIdentityEXT GLEW_GET_FUN(__glewMatrixLoadIdentityEXT) +#define glMatrixLoadTransposedEXT GLEW_GET_FUN(__glewMatrixLoadTransposedEXT) +#define glMatrixLoadTransposefEXT GLEW_GET_FUN(__glewMatrixLoadTransposefEXT) +#define glMatrixLoaddEXT GLEW_GET_FUN(__glewMatrixLoaddEXT) +#define glMatrixLoadfEXT GLEW_GET_FUN(__glewMatrixLoadfEXT) +#define glMatrixMultTransposedEXT GLEW_GET_FUN(__glewMatrixMultTransposedEXT) +#define glMatrixMultTransposefEXT GLEW_GET_FUN(__glewMatrixMultTransposefEXT) +#define glMatrixMultdEXT GLEW_GET_FUN(__glewMatrixMultdEXT) +#define glMatrixMultfEXT GLEW_GET_FUN(__glewMatrixMultfEXT) +#define glMatrixOrthoEXT GLEW_GET_FUN(__glewMatrixOrthoEXT) +#define glMatrixPopEXT GLEW_GET_FUN(__glewMatrixPopEXT) +#define glMatrixPushEXT GLEW_GET_FUN(__glewMatrixPushEXT) +#define glMatrixRotatedEXT GLEW_GET_FUN(__glewMatrixRotatedEXT) +#define glMatrixRotatefEXT GLEW_GET_FUN(__glewMatrixRotatefEXT) +#define glMatrixScaledEXT GLEW_GET_FUN(__glewMatrixScaledEXT) +#define glMatrixScalefEXT GLEW_GET_FUN(__glewMatrixScalefEXT) +#define glMatrixTranslatedEXT GLEW_GET_FUN(__glewMatrixTranslatedEXT) +#define glMatrixTranslatefEXT GLEW_GET_FUN(__glewMatrixTranslatefEXT) +#define glMultiTexBufferEXT GLEW_GET_FUN(__glewMultiTexBufferEXT) +#define glMultiTexCoordPointerEXT GLEW_GET_FUN(__glewMultiTexCoordPointerEXT) +#define glMultiTexEnvfEXT GLEW_GET_FUN(__glewMultiTexEnvfEXT) +#define glMultiTexEnvfvEXT GLEW_GET_FUN(__glewMultiTexEnvfvEXT) +#define glMultiTexEnviEXT GLEW_GET_FUN(__glewMultiTexEnviEXT) +#define glMultiTexEnvivEXT GLEW_GET_FUN(__glewMultiTexEnvivEXT) +#define glMultiTexGendEXT GLEW_GET_FUN(__glewMultiTexGendEXT) +#define glMultiTexGendvEXT GLEW_GET_FUN(__glewMultiTexGendvEXT) +#define glMultiTexGenfEXT GLEW_GET_FUN(__glewMultiTexGenfEXT) +#define glMultiTexGenfvEXT GLEW_GET_FUN(__glewMultiTexGenfvEXT) +#define glMultiTexGeniEXT GLEW_GET_FUN(__glewMultiTexGeniEXT) +#define glMultiTexGenivEXT GLEW_GET_FUN(__glewMultiTexGenivEXT) +#define glMultiTexImage1DEXT GLEW_GET_FUN(__glewMultiTexImage1DEXT) +#define glMultiTexImage2DEXT GLEW_GET_FUN(__glewMultiTexImage2DEXT) +#define glMultiTexImage3DEXT GLEW_GET_FUN(__glewMultiTexImage3DEXT) +#define glMultiTexParameterIivEXT GLEW_GET_FUN(__glewMultiTexParameterIivEXT) +#define glMultiTexParameterIuivEXT GLEW_GET_FUN(__glewMultiTexParameterIuivEXT) +#define glMultiTexParameterfEXT GLEW_GET_FUN(__glewMultiTexParameterfEXT) +#define glMultiTexParameterfvEXT GLEW_GET_FUN(__glewMultiTexParameterfvEXT) +#define glMultiTexParameteriEXT GLEW_GET_FUN(__glewMultiTexParameteriEXT) +#define glMultiTexParameterivEXT GLEW_GET_FUN(__glewMultiTexParameterivEXT) +#define glMultiTexRenderbufferEXT GLEW_GET_FUN(__glewMultiTexRenderbufferEXT) +#define glMultiTexSubImage1DEXT GLEW_GET_FUN(__glewMultiTexSubImage1DEXT) +#define glMultiTexSubImage2DEXT GLEW_GET_FUN(__glewMultiTexSubImage2DEXT) +#define glMultiTexSubImage3DEXT GLEW_GET_FUN(__glewMultiTexSubImage3DEXT) +#define glNamedBufferDataEXT GLEW_GET_FUN(__glewNamedBufferDataEXT) +#define glNamedBufferSubDataEXT GLEW_GET_FUN(__glewNamedBufferSubDataEXT) +#define glNamedCopyBufferSubDataEXT GLEW_GET_FUN(__glewNamedCopyBufferSubDataEXT) +#define glNamedFramebufferRenderbufferEXT GLEW_GET_FUN(__glewNamedFramebufferRenderbufferEXT) +#define glNamedFramebufferTexture1DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture1DEXT) +#define glNamedFramebufferTexture2DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture2DEXT) +#define glNamedFramebufferTexture3DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture3DEXT) +#define glNamedFramebufferTextureEXT GLEW_GET_FUN(__glewNamedFramebufferTextureEXT) +#define glNamedFramebufferTextureFaceEXT GLEW_GET_FUN(__glewNamedFramebufferTextureFaceEXT) +#define glNamedFramebufferTextureLayerEXT GLEW_GET_FUN(__glewNamedFramebufferTextureLayerEXT) +#define glNamedProgramLocalParameter4dEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dEXT) +#define glNamedProgramLocalParameter4dvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dvEXT) +#define glNamedProgramLocalParameter4fEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fEXT) +#define glNamedProgramLocalParameter4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fvEXT) +#define glNamedProgramLocalParameterI4iEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4iEXT) +#define glNamedProgramLocalParameterI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4ivEXT) +#define glNamedProgramLocalParameterI4uiEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uiEXT) +#define glNamedProgramLocalParameterI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uivEXT) +#define glNamedProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameters4fvEXT) +#define glNamedProgramLocalParametersI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4ivEXT) +#define glNamedProgramLocalParametersI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4uivEXT) +#define glNamedProgramStringEXT GLEW_GET_FUN(__glewNamedProgramStringEXT) +#define glNamedRenderbufferStorageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageEXT) +#define glNamedRenderbufferStorageMultisampleCoverageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleCoverageEXT) +#define glNamedRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleEXT) +#define glProgramUniform1fEXT GLEW_GET_FUN(__glewProgramUniform1fEXT) +#define glProgramUniform1fvEXT GLEW_GET_FUN(__glewProgramUniform1fvEXT) +#define glProgramUniform1iEXT GLEW_GET_FUN(__glewProgramUniform1iEXT) +#define glProgramUniform1ivEXT GLEW_GET_FUN(__glewProgramUniform1ivEXT) +#define glProgramUniform1uiEXT GLEW_GET_FUN(__glewProgramUniform1uiEXT) +#define glProgramUniform1uivEXT GLEW_GET_FUN(__glewProgramUniform1uivEXT) +#define glProgramUniform2fEXT GLEW_GET_FUN(__glewProgramUniform2fEXT) +#define glProgramUniform2fvEXT GLEW_GET_FUN(__glewProgramUniform2fvEXT) +#define glProgramUniform2iEXT GLEW_GET_FUN(__glewProgramUniform2iEXT) +#define glProgramUniform2ivEXT GLEW_GET_FUN(__glewProgramUniform2ivEXT) +#define glProgramUniform2uiEXT GLEW_GET_FUN(__glewProgramUniform2uiEXT) +#define glProgramUniform2uivEXT GLEW_GET_FUN(__glewProgramUniform2uivEXT) +#define glProgramUniform3fEXT GLEW_GET_FUN(__glewProgramUniform3fEXT) +#define glProgramUniform3fvEXT GLEW_GET_FUN(__glewProgramUniform3fvEXT) +#define glProgramUniform3iEXT GLEW_GET_FUN(__glewProgramUniform3iEXT) +#define glProgramUniform3ivEXT GLEW_GET_FUN(__glewProgramUniform3ivEXT) +#define glProgramUniform3uiEXT GLEW_GET_FUN(__glewProgramUniform3uiEXT) +#define glProgramUniform3uivEXT GLEW_GET_FUN(__glewProgramUniform3uivEXT) +#define glProgramUniform4fEXT GLEW_GET_FUN(__glewProgramUniform4fEXT) +#define glProgramUniform4fvEXT GLEW_GET_FUN(__glewProgramUniform4fvEXT) +#define glProgramUniform4iEXT GLEW_GET_FUN(__glewProgramUniform4iEXT) +#define glProgramUniform4ivEXT GLEW_GET_FUN(__glewProgramUniform4ivEXT) +#define glProgramUniform4uiEXT GLEW_GET_FUN(__glewProgramUniform4uiEXT) +#define glProgramUniform4uivEXT GLEW_GET_FUN(__glewProgramUniform4uivEXT) +#define glProgramUniformMatrix2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2fvEXT) +#define glProgramUniformMatrix2x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x3fvEXT) +#define glProgramUniformMatrix2x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x4fvEXT) +#define glProgramUniformMatrix3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3fvEXT) +#define glProgramUniformMatrix3x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x2fvEXT) +#define glProgramUniformMatrix3x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x4fvEXT) +#define glProgramUniformMatrix4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4fvEXT) +#define glProgramUniformMatrix4x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x2fvEXT) +#define glProgramUniformMatrix4x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x3fvEXT) +#define glPushClientAttribDefaultEXT GLEW_GET_FUN(__glewPushClientAttribDefaultEXT) +#define glTextureBufferEXT GLEW_GET_FUN(__glewTextureBufferEXT) +#define glTextureImage1DEXT GLEW_GET_FUN(__glewTextureImage1DEXT) +#define glTextureImage2DEXT GLEW_GET_FUN(__glewTextureImage2DEXT) +#define glTextureImage3DEXT GLEW_GET_FUN(__glewTextureImage3DEXT) +#define glTextureParameterIivEXT GLEW_GET_FUN(__glewTextureParameterIivEXT) +#define glTextureParameterIuivEXT GLEW_GET_FUN(__glewTextureParameterIuivEXT) +#define glTextureParameterfEXT GLEW_GET_FUN(__glewTextureParameterfEXT) +#define glTextureParameterfvEXT GLEW_GET_FUN(__glewTextureParameterfvEXT) +#define glTextureParameteriEXT GLEW_GET_FUN(__glewTextureParameteriEXT) +#define glTextureParameterivEXT GLEW_GET_FUN(__glewTextureParameterivEXT) +#define glTextureRenderbufferEXT GLEW_GET_FUN(__glewTextureRenderbufferEXT) +#define glTextureSubImage1DEXT GLEW_GET_FUN(__glewTextureSubImage1DEXT) +#define glTextureSubImage2DEXT GLEW_GET_FUN(__glewTextureSubImage2DEXT) +#define glTextureSubImage3DEXT GLEW_GET_FUN(__glewTextureSubImage3DEXT) +#define glUnmapNamedBufferEXT GLEW_GET_FUN(__glewUnmapNamedBufferEXT) +#define glVertexArrayColorOffsetEXT GLEW_GET_FUN(__glewVertexArrayColorOffsetEXT) +#define glVertexArrayEdgeFlagOffsetEXT GLEW_GET_FUN(__glewVertexArrayEdgeFlagOffsetEXT) +#define glVertexArrayFogCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayFogCoordOffsetEXT) +#define glVertexArrayIndexOffsetEXT GLEW_GET_FUN(__glewVertexArrayIndexOffsetEXT) +#define glVertexArrayMultiTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayMultiTexCoordOffsetEXT) +#define glVertexArrayNormalOffsetEXT GLEW_GET_FUN(__glewVertexArrayNormalOffsetEXT) +#define glVertexArraySecondaryColorOffsetEXT GLEW_GET_FUN(__glewVertexArraySecondaryColorOffsetEXT) +#define glVertexArrayTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayTexCoordOffsetEXT) +#define glVertexArrayVertexAttribIOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribIOffsetEXT) +#define glVertexArrayVertexAttribOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribOffsetEXT) +#define glVertexArrayVertexOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexOffsetEXT) + +#define GLEW_EXT_direct_state_access GLEW_GET_VAR(__GLEW_EXT_direct_state_access) + +#endif /* GL_EXT_direct_state_access */ + +/* -------------------------- GL_EXT_draw_buffers2 ------------------------- */ + +#ifndef GL_EXT_draw_buffers2 +#define GL_EXT_draw_buffers2 1 + +typedef void (GLAPIENTRY * PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum value, GLuint index, GLboolean* data); +typedef void (GLAPIENTRY * PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum value, GLuint index, GLint* data); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GLuint index); + +#define glColorMaskIndexedEXT GLEW_GET_FUN(__glewColorMaskIndexedEXT) +#define glDisableIndexedEXT GLEW_GET_FUN(__glewDisableIndexedEXT) +#define glEnableIndexedEXT GLEW_GET_FUN(__glewEnableIndexedEXT) +#define glGetBooleanIndexedvEXT GLEW_GET_FUN(__glewGetBooleanIndexedvEXT) +#define glGetIntegerIndexedvEXT GLEW_GET_FUN(__glewGetIntegerIndexedvEXT) +#define glIsEnabledIndexedEXT GLEW_GET_FUN(__glewIsEnabledIndexedEXT) + +#define GLEW_EXT_draw_buffers2 GLEW_GET_VAR(__GLEW_EXT_draw_buffers2) + +#endif /* GL_EXT_draw_buffers2 */ + +/* ------------------------- GL_EXT_draw_instanced ------------------------- */ + +#ifndef GL_EXT_draw_instanced +#define GL_EXT_draw_instanced 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount); + +#define glDrawArraysInstancedEXT GLEW_GET_FUN(__glewDrawArraysInstancedEXT) +#define glDrawElementsInstancedEXT GLEW_GET_FUN(__glewDrawElementsInstancedEXT) + +#define GLEW_EXT_draw_instanced GLEW_GET_VAR(__GLEW_EXT_draw_instanced) + +#endif /* GL_EXT_draw_instanced */ + +/* ----------------------- GL_EXT_draw_range_elements ---------------------- */ + +#ifndef GL_EXT_draw_range_elements +#define GL_EXT_draw_range_elements 1 + +#define GL_MAX_ELEMENTS_VERTICES_EXT 0x80E8 +#define GL_MAX_ELEMENTS_INDICES_EXT 0x80E9 + +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); + +#define glDrawRangeElementsEXT GLEW_GET_FUN(__glewDrawRangeElementsEXT) + +#define GLEW_EXT_draw_range_elements GLEW_GET_VAR(__GLEW_EXT_draw_range_elements) + +#endif /* GL_EXT_draw_range_elements */ + +/* ---------------------------- GL_EXT_fog_coord --------------------------- */ + +#ifndef GL_EXT_fog_coord +#define GL_EXT_fog_coord 1 + +#define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 +#define GL_FOG_COORDINATE_EXT 0x8451 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 +#define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 +#define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 + +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); + +#define glFogCoordPointerEXT GLEW_GET_FUN(__glewFogCoordPointerEXT) +#define glFogCoorddEXT GLEW_GET_FUN(__glewFogCoorddEXT) +#define glFogCoorddvEXT GLEW_GET_FUN(__glewFogCoorddvEXT) +#define glFogCoordfEXT GLEW_GET_FUN(__glewFogCoordfEXT) +#define glFogCoordfvEXT GLEW_GET_FUN(__glewFogCoordfvEXT) + +#define GLEW_EXT_fog_coord GLEW_GET_VAR(__GLEW_EXT_fog_coord) + +#endif /* GL_EXT_fog_coord */ + +/* ------------------------ GL_EXT_fragment_lighting ----------------------- */ + +#ifndef GL_EXT_fragment_lighting +#define GL_EXT_fragment_lighting 1 + +#define GL_FRAGMENT_LIGHTING_EXT 0x8400 +#define GL_FRAGMENT_COLOR_MATERIAL_EXT 0x8401 +#define GL_FRAGMENT_COLOR_MATERIAL_FACE_EXT 0x8402 +#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT 0x8403 +#define GL_MAX_FRAGMENT_LIGHTS_EXT 0x8404 +#define GL_MAX_ACTIVE_LIGHTS_EXT 0x8405 +#define GL_CURRENT_RASTER_NORMAL_EXT 0x8406 +#define GL_LIGHT_ENV_MODE_EXT 0x8407 +#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT 0x8408 +#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT 0x8409 +#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_EXT 0x840A +#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT 0x840B +#define GL_FRAGMENT_LIGHT0_EXT 0x840C +#define GL_FRAGMENT_LIGHT7_EXT 0x8413 + +typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALEXTPROC) (GLenum face, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFEXTPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVEXTPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIEXTPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVEXTPROC) (GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFEXTPROC) (GLenum light, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIEXTPROC) (GLenum light, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFEXTPROC) (GLenum face, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIEXTPROC) (GLenum face, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLLIGHTENVIEXTPROC) (GLenum pname, GLint param); + +#define glFragmentColorMaterialEXT GLEW_GET_FUN(__glewFragmentColorMaterialEXT) +#define glFragmentLightModelfEXT GLEW_GET_FUN(__glewFragmentLightModelfEXT) +#define glFragmentLightModelfvEXT GLEW_GET_FUN(__glewFragmentLightModelfvEXT) +#define glFragmentLightModeliEXT GLEW_GET_FUN(__glewFragmentLightModeliEXT) +#define glFragmentLightModelivEXT GLEW_GET_FUN(__glewFragmentLightModelivEXT) +#define glFragmentLightfEXT GLEW_GET_FUN(__glewFragmentLightfEXT) +#define glFragmentLightfvEXT GLEW_GET_FUN(__glewFragmentLightfvEXT) +#define glFragmentLightiEXT GLEW_GET_FUN(__glewFragmentLightiEXT) +#define glFragmentLightivEXT GLEW_GET_FUN(__glewFragmentLightivEXT) +#define glFragmentMaterialfEXT GLEW_GET_FUN(__glewFragmentMaterialfEXT) +#define glFragmentMaterialfvEXT GLEW_GET_FUN(__glewFragmentMaterialfvEXT) +#define glFragmentMaterialiEXT GLEW_GET_FUN(__glewFragmentMaterialiEXT) +#define glFragmentMaterialivEXT GLEW_GET_FUN(__glewFragmentMaterialivEXT) +#define glGetFragmentLightfvEXT GLEW_GET_FUN(__glewGetFragmentLightfvEXT) +#define glGetFragmentLightivEXT GLEW_GET_FUN(__glewGetFragmentLightivEXT) +#define glGetFragmentMaterialfvEXT GLEW_GET_FUN(__glewGetFragmentMaterialfvEXT) +#define glGetFragmentMaterialivEXT GLEW_GET_FUN(__glewGetFragmentMaterialivEXT) +#define glLightEnviEXT GLEW_GET_FUN(__glewLightEnviEXT) + +#define GLEW_EXT_fragment_lighting GLEW_GET_VAR(__GLEW_EXT_fragment_lighting) + +#endif /* GL_EXT_fragment_lighting */ + +/* ------------------------ GL_EXT_framebuffer_blit ------------------------ */ + +#ifndef GL_EXT_framebuffer_blit +#define GL_EXT_framebuffer_blit 1 + +#define GL_DRAW_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_READ_FRAMEBUFFER_EXT 0x8CA8 +#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING_EXT 0x8CAA + +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + +#define glBlitFramebufferEXT GLEW_GET_FUN(__glewBlitFramebufferEXT) + +#define GLEW_EXT_framebuffer_blit GLEW_GET_VAR(__GLEW_EXT_framebuffer_blit) + +#endif /* GL_EXT_framebuffer_blit */ + +/* --------------------- GL_EXT_framebuffer_multisample -------------------- */ + +#ifndef GL_EXT_framebuffer_multisample +#define GL_EXT_framebuffer_multisample 1 + +#define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56 +#define GL_MAX_SAMPLES_EXT 0x8D57 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewRenderbufferStorageMultisampleEXT) + +#define GLEW_EXT_framebuffer_multisample GLEW_GET_VAR(__GLEW_EXT_framebuffer_multisample) + +#endif /* GL_EXT_framebuffer_multisample */ + +/* --------------- GL_EXT_framebuffer_multisample_blit_scaled -------------- */ + +#ifndef GL_EXT_framebuffer_multisample_blit_scaled +#define GL_EXT_framebuffer_multisample_blit_scaled 1 + +#define GL_SCALED_RESOLVE_FASTEST_EXT 0x90BA +#define GL_SCALED_RESOLVE_NICEST_EXT 0x90BB + +#define GLEW_EXT_framebuffer_multisample_blit_scaled GLEW_GET_VAR(__GLEW_EXT_framebuffer_multisample_blit_scaled) + +#endif /* GL_EXT_framebuffer_multisample_blit_scaled */ + +/* ----------------------- GL_EXT_framebuffer_object ----------------------- */ + +#ifndef GL_EXT_framebuffer_object +#define GL_EXT_framebuffer_object 1 + +#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 +#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 +#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 +#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 +#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 +#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 +#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 +#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 +#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 +#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 +#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 +#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA +#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB +#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC +#define GL_COLOR_ATTACHMENT13_EXT 0x8CED +#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE +#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_RENDERBUFFER_EXT 0x8D41 +#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 +#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 +#define GL_STENCIL_INDEX1_EXT 0x8D46 +#define GL_STENCIL_INDEX4_EXT 0x8D47 +#define GL_STENCIL_INDEX8_EXT 0x8D48 +#define GL_STENCIL_INDEX16_EXT 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55 + +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + +#define glBindFramebufferEXT GLEW_GET_FUN(__glewBindFramebufferEXT) +#define glBindRenderbufferEXT GLEW_GET_FUN(__glewBindRenderbufferEXT) +#define glCheckFramebufferStatusEXT GLEW_GET_FUN(__glewCheckFramebufferStatusEXT) +#define glDeleteFramebuffersEXT GLEW_GET_FUN(__glewDeleteFramebuffersEXT) +#define glDeleteRenderbuffersEXT GLEW_GET_FUN(__glewDeleteRenderbuffersEXT) +#define glFramebufferRenderbufferEXT GLEW_GET_FUN(__glewFramebufferRenderbufferEXT) +#define glFramebufferTexture1DEXT GLEW_GET_FUN(__glewFramebufferTexture1DEXT) +#define glFramebufferTexture2DEXT GLEW_GET_FUN(__glewFramebufferTexture2DEXT) +#define glFramebufferTexture3DEXT GLEW_GET_FUN(__glewFramebufferTexture3DEXT) +#define glGenFramebuffersEXT GLEW_GET_FUN(__glewGenFramebuffersEXT) +#define glGenRenderbuffersEXT GLEW_GET_FUN(__glewGenRenderbuffersEXT) +#define glGenerateMipmapEXT GLEW_GET_FUN(__glewGenerateMipmapEXT) +#define glGetFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetFramebufferAttachmentParameterivEXT) +#define glGetRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetRenderbufferParameterivEXT) +#define glIsFramebufferEXT GLEW_GET_FUN(__glewIsFramebufferEXT) +#define glIsRenderbufferEXT GLEW_GET_FUN(__glewIsRenderbufferEXT) +#define glRenderbufferStorageEXT GLEW_GET_FUN(__glewRenderbufferStorageEXT) + +#define GLEW_EXT_framebuffer_object GLEW_GET_VAR(__GLEW_EXT_framebuffer_object) + +#endif /* GL_EXT_framebuffer_object */ + +/* ------------------------ GL_EXT_framebuffer_sRGB ------------------------ */ + +#ifndef GL_EXT_framebuffer_sRGB +#define GL_EXT_framebuffer_sRGB 1 + +#define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9 +#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA + +#define GLEW_EXT_framebuffer_sRGB GLEW_GET_VAR(__GLEW_EXT_framebuffer_sRGB) + +#endif /* GL_EXT_framebuffer_sRGB */ + +/* ------------------------ GL_EXT_geometry_shader4 ------------------------ */ + +#ifndef GL_EXT_geometry_shader4 +#define GL_EXT_geometry_shader4 1 + +#define GL_LINES_ADJACENCY_EXT 0xA +#define GL_LINE_STRIP_ADJACENCY_EXT 0xB +#define GL_TRIANGLES_ADJACENCY_EXT 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD +#define GL_PROGRAM_POINT_SIZE_EXT 0x8642 +#define GL_MAX_VARYING_COMPONENTS_EXT 0x8B4B +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9 +#define GL_GEOMETRY_SHADER_EXT 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA +#define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB +#define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC +#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD +#define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value); + +#define glFramebufferTextureEXT GLEW_GET_FUN(__glewFramebufferTextureEXT) +#define glFramebufferTextureFaceEXT GLEW_GET_FUN(__glewFramebufferTextureFaceEXT) +#define glProgramParameteriEXT GLEW_GET_FUN(__glewProgramParameteriEXT) + +#define GLEW_EXT_geometry_shader4 GLEW_GET_VAR(__GLEW_EXT_geometry_shader4) + +#endif /* GL_EXT_geometry_shader4 */ + +/* --------------------- GL_EXT_gpu_program_parameters --------------------- */ + +#ifndef GL_EXT_gpu_program_parameters +#define GL_EXT_gpu_program_parameters 1 + +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); + +#define glProgramEnvParameters4fvEXT GLEW_GET_FUN(__glewProgramEnvParameters4fvEXT) +#define glProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewProgramLocalParameters4fvEXT) + +#define GLEW_EXT_gpu_program_parameters GLEW_GET_VAR(__GLEW_EXT_gpu_program_parameters) + +#endif /* GL_EXT_gpu_program_parameters */ + +/* --------------------------- GL_EXT_gpu_shader4 -------------------------- */ + +#ifndef GL_EXT_gpu_shader4 +#define GL_EXT_gpu_shader4 1 + +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD +#define GL_SAMPLER_1D_ARRAY_EXT 0x8DC0 +#define GL_SAMPLER_2D_ARRAY_EXT 0x8DC1 +#define GL_SAMPLER_BUFFER_EXT 0x8DC2 +#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW_EXT 0x8DC5 +#define GL_UNSIGNED_INT_VEC2_EXT 0x8DC6 +#define GL_UNSIGNED_INT_VEC3_EXT 0x8DC7 +#define GL_UNSIGNED_INT_VEC4_EXT 0x8DC8 +#define GL_INT_SAMPLER_1D_EXT 0x8DC9 +#define GL_INT_SAMPLER_2D_EXT 0x8DCA +#define GL_INT_SAMPLER_3D_EXT 0x8DCB +#define GL_INT_SAMPLER_CUBE_EXT 0x8DCC +#define GL_INT_SAMPLER_2D_RECT_EXT 0x8DCD +#define GL_INT_SAMPLER_1D_ARRAY_EXT 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY_EXT 0x8DCF +#define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8 + +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program, GLuint color, const GLchar *name); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint location, GLuint *params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, GLenum pname, GLuint *params); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLuint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLuint x, GLuint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, const GLushort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + +#define glBindFragDataLocationEXT GLEW_GET_FUN(__glewBindFragDataLocationEXT) +#define glGetFragDataLocationEXT GLEW_GET_FUN(__glewGetFragDataLocationEXT) +#define glGetUniformuivEXT GLEW_GET_FUN(__glewGetUniformuivEXT) +#define glGetVertexAttribIivEXT GLEW_GET_FUN(__glewGetVertexAttribIivEXT) +#define glGetVertexAttribIuivEXT GLEW_GET_FUN(__glewGetVertexAttribIuivEXT) +#define glUniform1uiEXT GLEW_GET_FUN(__glewUniform1uiEXT) +#define glUniform1uivEXT GLEW_GET_FUN(__glewUniform1uivEXT) +#define glUniform2uiEXT GLEW_GET_FUN(__glewUniform2uiEXT) +#define glUniform2uivEXT GLEW_GET_FUN(__glewUniform2uivEXT) +#define glUniform3uiEXT GLEW_GET_FUN(__glewUniform3uiEXT) +#define glUniform3uivEXT GLEW_GET_FUN(__glewUniform3uivEXT) +#define glUniform4uiEXT GLEW_GET_FUN(__glewUniform4uiEXT) +#define glUniform4uivEXT GLEW_GET_FUN(__glewUniform4uivEXT) +#define glVertexAttribI1iEXT GLEW_GET_FUN(__glewVertexAttribI1iEXT) +#define glVertexAttribI1ivEXT GLEW_GET_FUN(__glewVertexAttribI1ivEXT) +#define glVertexAttribI1uiEXT GLEW_GET_FUN(__glewVertexAttribI1uiEXT) +#define glVertexAttribI1uivEXT GLEW_GET_FUN(__glewVertexAttribI1uivEXT) +#define glVertexAttribI2iEXT GLEW_GET_FUN(__glewVertexAttribI2iEXT) +#define glVertexAttribI2ivEXT GLEW_GET_FUN(__glewVertexAttribI2ivEXT) +#define glVertexAttribI2uiEXT GLEW_GET_FUN(__glewVertexAttribI2uiEXT) +#define glVertexAttribI2uivEXT GLEW_GET_FUN(__glewVertexAttribI2uivEXT) +#define glVertexAttribI3iEXT GLEW_GET_FUN(__glewVertexAttribI3iEXT) +#define glVertexAttribI3ivEXT GLEW_GET_FUN(__glewVertexAttribI3ivEXT) +#define glVertexAttribI3uiEXT GLEW_GET_FUN(__glewVertexAttribI3uiEXT) +#define glVertexAttribI3uivEXT GLEW_GET_FUN(__glewVertexAttribI3uivEXT) +#define glVertexAttribI4bvEXT GLEW_GET_FUN(__glewVertexAttribI4bvEXT) +#define glVertexAttribI4iEXT GLEW_GET_FUN(__glewVertexAttribI4iEXT) +#define glVertexAttribI4ivEXT GLEW_GET_FUN(__glewVertexAttribI4ivEXT) +#define glVertexAttribI4svEXT GLEW_GET_FUN(__glewVertexAttribI4svEXT) +#define glVertexAttribI4ubvEXT GLEW_GET_FUN(__glewVertexAttribI4ubvEXT) +#define glVertexAttribI4uiEXT GLEW_GET_FUN(__glewVertexAttribI4uiEXT) +#define glVertexAttribI4uivEXT GLEW_GET_FUN(__glewVertexAttribI4uivEXT) +#define glVertexAttribI4usvEXT GLEW_GET_FUN(__glewVertexAttribI4usvEXT) +#define glVertexAttribIPointerEXT GLEW_GET_FUN(__glewVertexAttribIPointerEXT) + +#define GLEW_EXT_gpu_shader4 GLEW_GET_VAR(__GLEW_EXT_gpu_shader4) + +#endif /* GL_EXT_gpu_shader4 */ + +/* ---------------------------- GL_EXT_histogram --------------------------- */ + +#ifndef GL_EXT_histogram +#define GL_EXT_histogram 1 + +#define GL_HISTOGRAM_EXT 0x8024 +#define GL_PROXY_HISTOGRAM_EXT 0x8025 +#define GL_HISTOGRAM_WIDTH_EXT 0x8026 +#define GL_HISTOGRAM_FORMAT_EXT 0x8027 +#define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C +#define GL_HISTOGRAM_SINK_EXT 0x802D +#define GL_MINMAX_EXT 0x802E +#define GL_MINMAX_FORMAT_EXT 0x802F +#define GL_MINMAX_SINK_EXT 0x8030 + +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target); + +#define glGetHistogramEXT GLEW_GET_FUN(__glewGetHistogramEXT) +#define glGetHistogramParameterfvEXT GLEW_GET_FUN(__glewGetHistogramParameterfvEXT) +#define glGetHistogramParameterivEXT GLEW_GET_FUN(__glewGetHistogramParameterivEXT) +#define glGetMinmaxEXT GLEW_GET_FUN(__glewGetMinmaxEXT) +#define glGetMinmaxParameterfvEXT GLEW_GET_FUN(__glewGetMinmaxParameterfvEXT) +#define glGetMinmaxParameterivEXT GLEW_GET_FUN(__glewGetMinmaxParameterivEXT) +#define glHistogramEXT GLEW_GET_FUN(__glewHistogramEXT) +#define glMinmaxEXT GLEW_GET_FUN(__glewMinmaxEXT) +#define glResetHistogramEXT GLEW_GET_FUN(__glewResetHistogramEXT) +#define glResetMinmaxEXT GLEW_GET_FUN(__glewResetMinmaxEXT) + +#define GLEW_EXT_histogram GLEW_GET_VAR(__GLEW_EXT_histogram) + +#endif /* GL_EXT_histogram */ + +/* ----------------------- GL_EXT_index_array_formats ---------------------- */ + +#ifndef GL_EXT_index_array_formats +#define GL_EXT_index_array_formats 1 + +#define GLEW_EXT_index_array_formats GLEW_GET_VAR(__GLEW_EXT_index_array_formats) + +#endif /* GL_EXT_index_array_formats */ + +/* --------------------------- GL_EXT_index_func --------------------------- */ + +#ifndef GL_EXT_index_func +#define GL_EXT_index_func 1 + +typedef void (GLAPIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLfloat ref); + +#define glIndexFuncEXT GLEW_GET_FUN(__glewIndexFuncEXT) + +#define GLEW_EXT_index_func GLEW_GET_VAR(__GLEW_EXT_index_func) + +#endif /* GL_EXT_index_func */ + +/* ------------------------- GL_EXT_index_material ------------------------- */ + +#ifndef GL_EXT_index_material +#define GL_EXT_index_material 1 + +typedef void (GLAPIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode); + +#define glIndexMaterialEXT GLEW_GET_FUN(__glewIndexMaterialEXT) + +#define GLEW_EXT_index_material GLEW_GET_VAR(__GLEW_EXT_index_material) + +#endif /* GL_EXT_index_material */ + +/* -------------------------- GL_EXT_index_texture ------------------------- */ + +#ifndef GL_EXT_index_texture +#define GL_EXT_index_texture 1 + +#define GLEW_EXT_index_texture GLEW_GET_VAR(__GLEW_EXT_index_texture) + +#endif /* GL_EXT_index_texture */ + +/* -------------------------- GL_EXT_light_texture ------------------------- */ + +#ifndef GL_EXT_light_texture +#define GL_EXT_light_texture 1 + +#define GL_FRAGMENT_MATERIAL_EXT 0x8349 +#define GL_FRAGMENT_NORMAL_EXT 0x834A +#define GL_FRAGMENT_COLOR_EXT 0x834C +#define GL_ATTENUATION_EXT 0x834D +#define GL_SHADOW_ATTENUATION_EXT 0x834E +#define GL_TEXTURE_APPLICATION_MODE_EXT 0x834F +#define GL_TEXTURE_LIGHT_EXT 0x8350 +#define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351 +#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 + +typedef void (GLAPIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname); +typedef void (GLAPIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode); + +#define glApplyTextureEXT GLEW_GET_FUN(__glewApplyTextureEXT) +#define glTextureLightEXT GLEW_GET_FUN(__glewTextureLightEXT) +#define glTextureMaterialEXT GLEW_GET_FUN(__glewTextureMaterialEXT) + +#define GLEW_EXT_light_texture GLEW_GET_VAR(__GLEW_EXT_light_texture) + +#endif /* GL_EXT_light_texture */ + +/* ------------------------- GL_EXT_misc_attribute ------------------------- */ + +#ifndef GL_EXT_misc_attribute +#define GL_EXT_misc_attribute 1 + +#define GLEW_EXT_misc_attribute GLEW_GET_VAR(__GLEW_EXT_misc_attribute) + +#endif /* GL_EXT_misc_attribute */ + +/* ------------------------ GL_EXT_multi_draw_arrays ----------------------- */ + +#ifndef GL_EXT_multi_draw_arrays +#define GL_EXT_multi_draw_arrays 1 + +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, GLsizei* count, GLenum type, const GLvoid **indices, GLsizei primcount); + +#define glMultiDrawArraysEXT GLEW_GET_FUN(__glewMultiDrawArraysEXT) +#define glMultiDrawElementsEXT GLEW_GET_FUN(__glewMultiDrawElementsEXT) + +#define GLEW_EXT_multi_draw_arrays GLEW_GET_VAR(__GLEW_EXT_multi_draw_arrays) + +#endif /* GL_EXT_multi_draw_arrays */ + +/* --------------------------- GL_EXT_multisample -------------------------- */ + +#ifndef GL_EXT_multisample +#define GL_EXT_multisample 1 + +#define GL_MULTISAMPLE_EXT 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_EXT 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F +#define GL_SAMPLE_MASK_EXT 0x80A0 +#define GL_1PASS_EXT 0x80A1 +#define GL_2PASS_0_EXT 0x80A2 +#define GL_2PASS_1_EXT 0x80A3 +#define GL_4PASS_0_EXT 0x80A4 +#define GL_4PASS_1_EXT 0x80A5 +#define GL_4PASS_2_EXT 0x80A6 +#define GL_4PASS_3_EXT 0x80A7 +#define GL_SAMPLE_BUFFERS_EXT 0x80A8 +#define GL_SAMPLES_EXT 0x80A9 +#define GL_SAMPLE_MASK_VALUE_EXT 0x80AA +#define GL_SAMPLE_MASK_INVERT_EXT 0x80AB +#define GL_SAMPLE_PATTERN_EXT 0x80AC +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); + +#define glSampleMaskEXT GLEW_GET_FUN(__glewSampleMaskEXT) +#define glSamplePatternEXT GLEW_GET_FUN(__glewSamplePatternEXT) + +#define GLEW_EXT_multisample GLEW_GET_VAR(__GLEW_EXT_multisample) + +#endif /* GL_EXT_multisample */ + +/* ---------------------- GL_EXT_packed_depth_stencil ---------------------- */ + +#ifndef GL_EXT_packed_depth_stencil +#define GL_EXT_packed_depth_stencil 1 + +#define GL_DEPTH_STENCIL_EXT 0x84F9 +#define GL_UNSIGNED_INT_24_8_EXT 0x84FA +#define GL_DEPTH24_STENCIL8_EXT 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE_EXT 0x88F1 + +#define GLEW_EXT_packed_depth_stencil GLEW_GET_VAR(__GLEW_EXT_packed_depth_stencil) + +#endif /* GL_EXT_packed_depth_stencil */ + +/* -------------------------- GL_EXT_packed_float -------------------------- */ + +#ifndef GL_EXT_packed_float +#define GL_EXT_packed_float 1 + +#define GL_R11F_G11F_B10F_EXT 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B +#define GL_RGBA_SIGNED_COMPONENTS_EXT 0x8C3C + +#define GLEW_EXT_packed_float GLEW_GET_VAR(__GLEW_EXT_packed_float) + +#endif /* GL_EXT_packed_float */ + +/* -------------------------- GL_EXT_packed_pixels ------------------------- */ + +#ifndef GL_EXT_packed_pixels +#define GL_EXT_packed_pixels 1 + +#define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 + +#define GLEW_EXT_packed_pixels GLEW_GET_VAR(__GLEW_EXT_packed_pixels) + +#endif /* GL_EXT_packed_pixels */ + +/* ------------------------ GL_EXT_paletted_texture ------------------------ */ + +#ifndef GL_EXT_paletted_texture +#define GL_EXT_paletted_texture 1 + +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_COLOR_TABLE_FORMAT_EXT 0x80D8 +#define GL_COLOR_TABLE_WIDTH_EXT 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 +#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED +#define GL_TEXTURE_CUBE_MAP_ARB 0x8513 +#define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B + +typedef void (GLAPIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, void* data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); + +#define glColorTableEXT GLEW_GET_FUN(__glewColorTableEXT) +#define glGetColorTableEXT GLEW_GET_FUN(__glewGetColorTableEXT) +#define glGetColorTableParameterfvEXT GLEW_GET_FUN(__glewGetColorTableParameterfvEXT) +#define glGetColorTableParameterivEXT GLEW_GET_FUN(__glewGetColorTableParameterivEXT) + +#define GLEW_EXT_paletted_texture GLEW_GET_VAR(__GLEW_EXT_paletted_texture) + +#endif /* GL_EXT_paletted_texture */ + +/* ----------------------- GL_EXT_pixel_buffer_object ---------------------- */ + +#ifndef GL_EXT_pixel_buffer_object +#define GL_EXT_pixel_buffer_object 1 + +#define GL_PIXEL_PACK_BUFFER_EXT 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF + +#define GLEW_EXT_pixel_buffer_object GLEW_GET_VAR(__GLEW_EXT_pixel_buffer_object) + +#endif /* GL_EXT_pixel_buffer_object */ + +/* ------------------------- GL_EXT_pixel_transform ------------------------ */ + +#ifndef GL_EXT_pixel_transform +#define GL_EXT_pixel_transform 1 + +#define GL_PIXEL_TRANSFORM_2D_EXT 0x8330 +#define GL_PIXEL_MAG_FILTER_EXT 0x8331 +#define GL_PIXEL_MIN_FILTER_EXT 0x8332 +#define GL_PIXEL_CUBIC_WEIGHT_EXT 0x8333 +#define GL_CUBIC_EXT 0x8334 +#define GL_AVERAGE_EXT 0x8335 +#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336 +#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337 +#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT 0x8338 + +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glGetPixelTransformParameterfvEXT GLEW_GET_FUN(__glewGetPixelTransformParameterfvEXT) +#define glGetPixelTransformParameterivEXT GLEW_GET_FUN(__glewGetPixelTransformParameterivEXT) +#define glPixelTransformParameterfEXT GLEW_GET_FUN(__glewPixelTransformParameterfEXT) +#define glPixelTransformParameterfvEXT GLEW_GET_FUN(__glewPixelTransformParameterfvEXT) +#define glPixelTransformParameteriEXT GLEW_GET_FUN(__glewPixelTransformParameteriEXT) +#define glPixelTransformParameterivEXT GLEW_GET_FUN(__glewPixelTransformParameterivEXT) + +#define GLEW_EXT_pixel_transform GLEW_GET_VAR(__GLEW_EXT_pixel_transform) + +#endif /* GL_EXT_pixel_transform */ + +/* ------------------- GL_EXT_pixel_transform_color_table ------------------ */ + +#ifndef GL_EXT_pixel_transform_color_table +#define GL_EXT_pixel_transform_color_table 1 + +#define GLEW_EXT_pixel_transform_color_table GLEW_GET_VAR(__GLEW_EXT_pixel_transform_color_table) + +#endif /* GL_EXT_pixel_transform_color_table */ + +/* ------------------------ GL_EXT_point_parameters ------------------------ */ + +#ifndef GL_EXT_point_parameters +#define GL_EXT_point_parameters 1 + +#define GL_POINT_SIZE_MIN_EXT 0x8126 +#define GL_POINT_SIZE_MAX_EXT 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 +#define GL_DISTANCE_ATTENUATION_EXT 0x8129 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat* params); + +#define glPointParameterfEXT GLEW_GET_FUN(__glewPointParameterfEXT) +#define glPointParameterfvEXT GLEW_GET_FUN(__glewPointParameterfvEXT) + +#define GLEW_EXT_point_parameters GLEW_GET_VAR(__GLEW_EXT_point_parameters) + +#endif /* GL_EXT_point_parameters */ + +/* ------------------------- GL_EXT_polygon_offset ------------------------- */ + +#ifndef GL_EXT_polygon_offset +#define GL_EXT_polygon_offset 1 + +#define GL_POLYGON_OFFSET_EXT 0x8037 +#define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 +#define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 + +typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias); + +#define glPolygonOffsetEXT GLEW_GET_FUN(__glewPolygonOffsetEXT) + +#define GLEW_EXT_polygon_offset GLEW_GET_VAR(__GLEW_EXT_polygon_offset) + +#endif /* GL_EXT_polygon_offset */ + +/* ------------------------ GL_EXT_provoking_vertex ------------------------ */ + +#ifndef GL_EXT_provoking_vertex +#define GL_EXT_provoking_vertex 1 + +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D +#define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E +#define GL_PROVOKING_VERTEX_EXT 0x8E4F + +typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXEXTPROC) (GLenum mode); + +#define glProvokingVertexEXT GLEW_GET_FUN(__glewProvokingVertexEXT) + +#define GLEW_EXT_provoking_vertex GLEW_GET_VAR(__GLEW_EXT_provoking_vertex) + +#endif /* GL_EXT_provoking_vertex */ + +/* ------------------------- GL_EXT_rescale_normal ------------------------- */ + +#ifndef GL_EXT_rescale_normal +#define GL_EXT_rescale_normal 1 + +#define GL_RESCALE_NORMAL_EXT 0x803A + +#define GLEW_EXT_rescale_normal GLEW_GET_VAR(__GLEW_EXT_rescale_normal) + +#endif /* GL_EXT_rescale_normal */ + +/* -------------------------- GL_EXT_scene_marker -------------------------- */ + +#ifndef GL_EXT_scene_marker +#define GL_EXT_scene_marker 1 + +typedef void (GLAPIENTRY * PFNGLBEGINSCENEEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLENDSCENEEXTPROC) (void); + +#define glBeginSceneEXT GLEW_GET_FUN(__glewBeginSceneEXT) +#define glEndSceneEXT GLEW_GET_FUN(__glewEndSceneEXT) + +#define GLEW_EXT_scene_marker GLEW_GET_VAR(__GLEW_EXT_scene_marker) + +#endif /* GL_EXT_scene_marker */ + +/* ------------------------- GL_EXT_secondary_color ------------------------ */ + +#ifndef GL_EXT_secondary_color +#define GL_EXT_secondary_color 1 + +#define GL_COLOR_SUM_EXT 0x8458 +#define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D +#define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E + +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + +#define glSecondaryColor3bEXT GLEW_GET_FUN(__glewSecondaryColor3bEXT) +#define glSecondaryColor3bvEXT GLEW_GET_FUN(__glewSecondaryColor3bvEXT) +#define glSecondaryColor3dEXT GLEW_GET_FUN(__glewSecondaryColor3dEXT) +#define glSecondaryColor3dvEXT GLEW_GET_FUN(__glewSecondaryColor3dvEXT) +#define glSecondaryColor3fEXT GLEW_GET_FUN(__glewSecondaryColor3fEXT) +#define glSecondaryColor3fvEXT GLEW_GET_FUN(__glewSecondaryColor3fvEXT) +#define glSecondaryColor3iEXT GLEW_GET_FUN(__glewSecondaryColor3iEXT) +#define glSecondaryColor3ivEXT GLEW_GET_FUN(__glewSecondaryColor3ivEXT) +#define glSecondaryColor3sEXT GLEW_GET_FUN(__glewSecondaryColor3sEXT) +#define glSecondaryColor3svEXT GLEW_GET_FUN(__glewSecondaryColor3svEXT) +#define glSecondaryColor3ubEXT GLEW_GET_FUN(__glewSecondaryColor3ubEXT) +#define glSecondaryColor3ubvEXT GLEW_GET_FUN(__glewSecondaryColor3ubvEXT) +#define glSecondaryColor3uiEXT GLEW_GET_FUN(__glewSecondaryColor3uiEXT) +#define glSecondaryColor3uivEXT GLEW_GET_FUN(__glewSecondaryColor3uivEXT) +#define glSecondaryColor3usEXT GLEW_GET_FUN(__glewSecondaryColor3usEXT) +#define glSecondaryColor3usvEXT GLEW_GET_FUN(__glewSecondaryColor3usvEXT) +#define glSecondaryColorPointerEXT GLEW_GET_FUN(__glewSecondaryColorPointerEXT) + +#define GLEW_EXT_secondary_color GLEW_GET_VAR(__GLEW_EXT_secondary_color) + +#endif /* GL_EXT_secondary_color */ + +/* --------------------- GL_EXT_separate_shader_objects -------------------- */ + +#ifndef GL_EXT_separate_shader_objects +#define GL_EXT_separate_shader_objects 1 + +#define GL_ACTIVE_PROGRAM_EXT 0x8B8D + +typedef void (GLAPIENTRY * PFNGLACTIVEPROGRAMEXTPROC) (GLuint program); +typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROGRAMEXTPROC) (GLenum type, const char* string); +typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint program); + +#define glActiveProgramEXT GLEW_GET_FUN(__glewActiveProgramEXT) +#define glCreateShaderProgramEXT GLEW_GET_FUN(__glewCreateShaderProgramEXT) +#define glUseShaderProgramEXT GLEW_GET_FUN(__glewUseShaderProgramEXT) + +#define GLEW_EXT_separate_shader_objects GLEW_GET_VAR(__GLEW_EXT_separate_shader_objects) + +#endif /* GL_EXT_separate_shader_objects */ + +/* --------------------- GL_EXT_separate_specular_color -------------------- */ + +#ifndef GL_EXT_separate_specular_color +#define GL_EXT_separate_specular_color 1 + +#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT 0x81F8 +#define GL_SINGLE_COLOR_EXT 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR_EXT 0x81FA + +#define GLEW_EXT_separate_specular_color GLEW_GET_VAR(__GLEW_EXT_separate_specular_color) + +#endif /* GL_EXT_separate_specular_color */ + +/* --------------------- GL_EXT_shader_image_load_store -------------------- */ + +#ifndef GL_EXT_shader_image_load_store +#define GL_EXT_shader_image_load_store 1 + +#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT 0x00000001 +#define GL_ELEMENT_ARRAY_BARRIER_BIT_EXT 0x00000002 +#define GL_UNIFORM_BARRIER_BIT_EXT 0x00000004 +#define GL_TEXTURE_FETCH_BARRIER_BIT_EXT 0x00000008 +#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT 0x00000020 +#define GL_COMMAND_BARRIER_BIT_EXT 0x00000040 +#define GL_PIXEL_BUFFER_BARRIER_BIT_EXT 0x00000080 +#define GL_TEXTURE_UPDATE_BARRIER_BIT_EXT 0x00000100 +#define GL_BUFFER_UPDATE_BARRIER_BIT_EXT 0x00000200 +#define GL_FRAMEBUFFER_BARRIER_BIT_EXT 0x00000400 +#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT 0x00000800 +#define GL_ATOMIC_COUNTER_BARRIER_BIT_EXT 0x00001000 +#define GL_MAX_IMAGE_UNITS_EXT 0x8F38 +#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT 0x8F39 +#define GL_IMAGE_BINDING_NAME_EXT 0x8F3A +#define GL_IMAGE_BINDING_LEVEL_EXT 0x8F3B +#define GL_IMAGE_BINDING_LAYERED_EXT 0x8F3C +#define GL_IMAGE_BINDING_LAYER_EXT 0x8F3D +#define GL_IMAGE_BINDING_ACCESS_EXT 0x8F3E +#define GL_IMAGE_1D_EXT 0x904C +#define GL_IMAGE_2D_EXT 0x904D +#define GL_IMAGE_3D_EXT 0x904E +#define GL_IMAGE_2D_RECT_EXT 0x904F +#define GL_IMAGE_CUBE_EXT 0x9050 +#define GL_IMAGE_BUFFER_EXT 0x9051 +#define GL_IMAGE_1D_ARRAY_EXT 0x9052 +#define GL_IMAGE_2D_ARRAY_EXT 0x9053 +#define GL_IMAGE_CUBE_MAP_ARRAY_EXT 0x9054 +#define GL_IMAGE_2D_MULTISAMPLE_EXT 0x9055 +#define GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9056 +#define GL_INT_IMAGE_1D_EXT 0x9057 +#define GL_INT_IMAGE_2D_EXT 0x9058 +#define GL_INT_IMAGE_3D_EXT 0x9059 +#define GL_INT_IMAGE_2D_RECT_EXT 0x905A +#define GL_INT_IMAGE_CUBE_EXT 0x905B +#define GL_INT_IMAGE_BUFFER_EXT 0x905C +#define GL_INT_IMAGE_1D_ARRAY_EXT 0x905D +#define GL_INT_IMAGE_2D_ARRAY_EXT 0x905E +#define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x905F +#define GL_INT_IMAGE_2D_MULTISAMPLE_EXT 0x9060 +#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9061 +#define GL_UNSIGNED_INT_IMAGE_1D_EXT 0x9062 +#define GL_UNSIGNED_INT_IMAGE_2D_EXT 0x9063 +#define GL_UNSIGNED_INT_IMAGE_3D_EXT 0x9064 +#define GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT 0x9065 +#define GL_UNSIGNED_INT_IMAGE_CUBE_EXT 0x9066 +#define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT 0x9067 +#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT 0x9068 +#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT 0x9069 +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x906A +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT 0x906B +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x906C +#define GL_MAX_IMAGE_SAMPLES_EXT 0x906D +#define GL_IMAGE_BINDING_FORMAT_EXT 0x906E +#define GL_ALL_BARRIER_BITS_EXT 0xFFFFFFFF + +typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTUREEXTPROC) (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format); +typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); + +#define glBindImageTextureEXT GLEW_GET_FUN(__glewBindImageTextureEXT) +#define glMemoryBarrierEXT GLEW_GET_FUN(__glewMemoryBarrierEXT) + +#define GLEW_EXT_shader_image_load_store GLEW_GET_VAR(__GLEW_EXT_shader_image_load_store) + +#endif /* GL_EXT_shader_image_load_store */ + +/* -------------------------- GL_EXT_shadow_funcs -------------------------- */ + +#ifndef GL_EXT_shadow_funcs +#define GL_EXT_shadow_funcs 1 + +#define GLEW_EXT_shadow_funcs GLEW_GET_VAR(__GLEW_EXT_shadow_funcs) + +#endif /* GL_EXT_shadow_funcs */ + +/* --------------------- GL_EXT_shared_texture_palette --------------------- */ + +#ifndef GL_EXT_shared_texture_palette +#define GL_EXT_shared_texture_palette 1 + +#define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB + +#define GLEW_EXT_shared_texture_palette GLEW_GET_VAR(__GLEW_EXT_shared_texture_palette) + +#endif /* GL_EXT_shared_texture_palette */ + +/* ------------------------ GL_EXT_stencil_clear_tag ----------------------- */ + +#ifndef GL_EXT_stencil_clear_tag +#define GL_EXT_stencil_clear_tag 1 + +#define GL_STENCIL_TAG_BITS_EXT 0x88F2 +#define GL_STENCIL_CLEAR_TAG_VALUE_EXT 0x88F3 + +#define GLEW_EXT_stencil_clear_tag GLEW_GET_VAR(__GLEW_EXT_stencil_clear_tag) + +#endif /* GL_EXT_stencil_clear_tag */ + +/* ------------------------ GL_EXT_stencil_two_side ------------------------ */ + +#ifndef GL_EXT_stencil_two_side +#define GL_EXT_stencil_two_side 1 + +#define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910 +#define GL_ACTIVE_STENCIL_FACE_EXT 0x8911 + +typedef void (GLAPIENTRY * PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); + +#define glActiveStencilFaceEXT GLEW_GET_FUN(__glewActiveStencilFaceEXT) + +#define GLEW_EXT_stencil_two_side GLEW_GET_VAR(__GLEW_EXT_stencil_two_side) + +#endif /* GL_EXT_stencil_two_side */ + +/* -------------------------- GL_EXT_stencil_wrap -------------------------- */ + +#ifndef GL_EXT_stencil_wrap +#define GL_EXT_stencil_wrap 1 + +#define GL_INCR_WRAP_EXT 0x8507 +#define GL_DECR_WRAP_EXT 0x8508 + +#define GLEW_EXT_stencil_wrap GLEW_GET_VAR(__GLEW_EXT_stencil_wrap) + +#endif /* GL_EXT_stencil_wrap */ + +/* --------------------------- GL_EXT_subtexture --------------------------- */ + +#ifndef GL_EXT_subtexture +#define GL_EXT_subtexture 1 + +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); + +#define glTexSubImage1DEXT GLEW_GET_FUN(__glewTexSubImage1DEXT) +#define glTexSubImage2DEXT GLEW_GET_FUN(__glewTexSubImage2DEXT) +#define glTexSubImage3DEXT GLEW_GET_FUN(__glewTexSubImage3DEXT) + +#define GLEW_EXT_subtexture GLEW_GET_VAR(__GLEW_EXT_subtexture) + +#endif /* GL_EXT_subtexture */ + +/* ----------------------------- GL_EXT_texture ---------------------------- */ + +#ifndef GL_EXT_texture +#define GL_EXT_texture 1 + +#define GL_ALPHA4_EXT 0x803B +#define GL_ALPHA8_EXT 0x803C +#define GL_ALPHA12_EXT 0x803D +#define GL_ALPHA16_EXT 0x803E +#define GL_LUMINANCE4_EXT 0x803F +#define GL_LUMINANCE8_EXT 0x8040 +#define GL_LUMINANCE12_EXT 0x8041 +#define GL_LUMINANCE16_EXT 0x8042 +#define GL_LUMINANCE4_ALPHA4_EXT 0x8043 +#define GL_LUMINANCE6_ALPHA2_EXT 0x8044 +#define GL_LUMINANCE8_ALPHA8_EXT 0x8045 +#define GL_LUMINANCE12_ALPHA4_EXT 0x8046 +#define GL_LUMINANCE12_ALPHA12_EXT 0x8047 +#define GL_LUMINANCE16_ALPHA16_EXT 0x8048 +#define GL_INTENSITY_EXT 0x8049 +#define GL_INTENSITY4_EXT 0x804A +#define GL_INTENSITY8_EXT 0x804B +#define GL_INTENSITY12_EXT 0x804C +#define GL_INTENSITY16_EXT 0x804D +#define GL_RGB2_EXT 0x804E +#define GL_RGB4_EXT 0x804F +#define GL_RGB5_EXT 0x8050 +#define GL_RGB8_EXT 0x8051 +#define GL_RGB10_EXT 0x8052 +#define GL_RGB12_EXT 0x8053 +#define GL_RGB16_EXT 0x8054 +#define GL_RGBA2_EXT 0x8055 +#define GL_RGBA4_EXT 0x8056 +#define GL_RGB5_A1_EXT 0x8057 +#define GL_RGBA8_EXT 0x8058 +#define GL_RGB10_A2_EXT 0x8059 +#define GL_RGBA12_EXT 0x805A +#define GL_RGBA16_EXT 0x805B +#define GL_TEXTURE_RED_SIZE_EXT 0x805C +#define GL_TEXTURE_GREEN_SIZE_EXT 0x805D +#define GL_TEXTURE_BLUE_SIZE_EXT 0x805E +#define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061 +#define GL_REPLACE_EXT 0x8062 +#define GL_PROXY_TEXTURE_1D_EXT 0x8063 +#define GL_PROXY_TEXTURE_2D_EXT 0x8064 + +#define GLEW_EXT_texture GLEW_GET_VAR(__GLEW_EXT_texture) + +#endif /* GL_EXT_texture */ + +/* ---------------------------- GL_EXT_texture3D --------------------------- */ + +#ifndef GL_EXT_texture3D +#define GL_EXT_texture3D 1 + +#define GL_PACK_SKIP_IMAGES_EXT 0x806B +#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C +#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D +#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_TEXTURE_DEPTH_EXT 0x8071 +#define GL_TEXTURE_WRAP_R_EXT 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 + +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); + +#define glTexImage3DEXT GLEW_GET_FUN(__glewTexImage3DEXT) + +#define GLEW_EXT_texture3D GLEW_GET_VAR(__GLEW_EXT_texture3D) + +#endif /* GL_EXT_texture3D */ + +/* -------------------------- GL_EXT_texture_array ------------------------- */ + +#ifndef GL_EXT_texture_array +#define GL_EXT_texture_array 1 + +#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E +#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT 0x88FF +#define GL_TEXTURE_1D_ARRAY_EXT 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY_EXT 0x8C19 +#define GL_TEXTURE_2D_ARRAY_EXT 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY_EXT 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY_EXT 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY_EXT 0x8C1D + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + +#define glFramebufferTextureLayerEXT GLEW_GET_FUN(__glewFramebufferTextureLayerEXT) + +#define GLEW_EXT_texture_array GLEW_GET_VAR(__GLEW_EXT_texture_array) + +#endif /* GL_EXT_texture_array */ + +/* ---------------------- GL_EXT_texture_buffer_object --------------------- */ + +#ifndef GL_EXT_texture_buffer_object +#define GL_EXT_texture_buffer_object 1 + +#define GL_TEXTURE_BUFFER_EXT 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D +#define GL_TEXTURE_BUFFER_FORMAT_EXT 0x8C2E + +typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum internalformat, GLuint buffer); + +#define glTexBufferEXT GLEW_GET_FUN(__glewTexBufferEXT) + +#define GLEW_EXT_texture_buffer_object GLEW_GET_VAR(__GLEW_EXT_texture_buffer_object) + +#endif /* GL_EXT_texture_buffer_object */ + +/* -------------------- GL_EXT_texture_compression_dxt1 -------------------- */ + +#ifndef GL_EXT_texture_compression_dxt1 +#define GL_EXT_texture_compression_dxt1 1 + +#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 + +#define GLEW_EXT_texture_compression_dxt1 GLEW_GET_VAR(__GLEW_EXT_texture_compression_dxt1) + +#endif /* GL_EXT_texture_compression_dxt1 */ + +/* -------------------- GL_EXT_texture_compression_latc -------------------- */ + +#ifndef GL_EXT_texture_compression_latc +#define GL_EXT_texture_compression_latc 1 + +#define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70 +#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71 +#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72 +#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73 + +#define GLEW_EXT_texture_compression_latc GLEW_GET_VAR(__GLEW_EXT_texture_compression_latc) + +#endif /* GL_EXT_texture_compression_latc */ + +/* -------------------- GL_EXT_texture_compression_rgtc -------------------- */ + +#ifndef GL_EXT_texture_compression_rgtc +#define GL_EXT_texture_compression_rgtc 1 + +#define GL_COMPRESSED_RED_RGTC1_EXT 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC +#define GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD +#define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE + +#define GLEW_EXT_texture_compression_rgtc GLEW_GET_VAR(__GLEW_EXT_texture_compression_rgtc) + +#endif /* GL_EXT_texture_compression_rgtc */ + +/* -------------------- GL_EXT_texture_compression_s3tc -------------------- */ + +#ifndef GL_EXT_texture_compression_s3tc +#define GL_EXT_texture_compression_s3tc 1 + +#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 + +#define GLEW_EXT_texture_compression_s3tc GLEW_GET_VAR(__GLEW_EXT_texture_compression_s3tc) + +#endif /* GL_EXT_texture_compression_s3tc */ + +/* ------------------------ GL_EXT_texture_cube_map ------------------------ */ + +#ifndef GL_EXT_texture_cube_map +#define GL_EXT_texture_cube_map 1 + +#define GL_NORMAL_MAP_EXT 0x8511 +#define GL_REFLECTION_MAP_EXT 0x8512 +#define GL_TEXTURE_CUBE_MAP_EXT 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C + +#define GLEW_EXT_texture_cube_map GLEW_GET_VAR(__GLEW_EXT_texture_cube_map) + +#endif /* GL_EXT_texture_cube_map */ + +/* ----------------------- GL_EXT_texture_edge_clamp ----------------------- */ + +#ifndef GL_EXT_texture_edge_clamp +#define GL_EXT_texture_edge_clamp 1 + +#define GL_CLAMP_TO_EDGE_EXT 0x812F + +#define GLEW_EXT_texture_edge_clamp GLEW_GET_VAR(__GLEW_EXT_texture_edge_clamp) + +#endif /* GL_EXT_texture_edge_clamp */ + +/* --------------------------- GL_EXT_texture_env -------------------------- */ + +#ifndef GL_EXT_texture_env +#define GL_EXT_texture_env 1 + +#define GL_TEXTURE_ENV0_EXT 0 +#define GL_ENV_BLEND_EXT 0 +#define GL_TEXTURE_ENV_SHIFT_EXT 0 +#define GL_ENV_REPLACE_EXT 0 +#define GL_ENV_ADD_EXT 0 +#define GL_ENV_SUBTRACT_EXT 0 +#define GL_TEXTURE_ENV_MODE_ALPHA_EXT 0 +#define GL_ENV_REVERSE_SUBTRACT_EXT 0 +#define GL_ENV_REVERSE_BLEND_EXT 0 +#define GL_ENV_COPY_EXT 0 +#define GL_ENV_MODULATE_EXT 0 + +#define GLEW_EXT_texture_env GLEW_GET_VAR(__GLEW_EXT_texture_env) + +#endif /* GL_EXT_texture_env */ + +/* ------------------------- GL_EXT_texture_env_add ------------------------ */ + +#ifndef GL_EXT_texture_env_add +#define GL_EXT_texture_env_add 1 + +#define GLEW_EXT_texture_env_add GLEW_GET_VAR(__GLEW_EXT_texture_env_add) + +#endif /* GL_EXT_texture_env_add */ + +/* ----------------------- GL_EXT_texture_env_combine ---------------------- */ + +#ifndef GL_EXT_texture_env_combine +#define GL_EXT_texture_env_combine 1 + +#define GL_COMBINE_EXT 0x8570 +#define GL_COMBINE_RGB_EXT 0x8571 +#define GL_COMBINE_ALPHA_EXT 0x8572 +#define GL_RGB_SCALE_EXT 0x8573 +#define GL_ADD_SIGNED_EXT 0x8574 +#define GL_INTERPOLATE_EXT 0x8575 +#define GL_CONSTANT_EXT 0x8576 +#define GL_PRIMARY_COLOR_EXT 0x8577 +#define GL_PREVIOUS_EXT 0x8578 +#define GL_SOURCE0_RGB_EXT 0x8580 +#define GL_SOURCE1_RGB_EXT 0x8581 +#define GL_SOURCE2_RGB_EXT 0x8582 +#define GL_SOURCE0_ALPHA_EXT 0x8588 +#define GL_SOURCE1_ALPHA_EXT 0x8589 +#define GL_SOURCE2_ALPHA_EXT 0x858A +#define GL_OPERAND0_RGB_EXT 0x8590 +#define GL_OPERAND1_RGB_EXT 0x8591 +#define GL_OPERAND2_RGB_EXT 0x8592 +#define GL_OPERAND0_ALPHA_EXT 0x8598 +#define GL_OPERAND1_ALPHA_EXT 0x8599 +#define GL_OPERAND2_ALPHA_EXT 0x859A + +#define GLEW_EXT_texture_env_combine GLEW_GET_VAR(__GLEW_EXT_texture_env_combine) + +#endif /* GL_EXT_texture_env_combine */ + +/* ------------------------ GL_EXT_texture_env_dot3 ------------------------ */ + +#ifndef GL_EXT_texture_env_dot3 +#define GL_EXT_texture_env_dot3 1 + +#define GL_DOT3_RGB_EXT 0x8740 +#define GL_DOT3_RGBA_EXT 0x8741 + +#define GLEW_EXT_texture_env_dot3 GLEW_GET_VAR(__GLEW_EXT_texture_env_dot3) + +#endif /* GL_EXT_texture_env_dot3 */ + +/* ------------------- GL_EXT_texture_filter_anisotropic ------------------- */ + +#ifndef GL_EXT_texture_filter_anisotropic +#define GL_EXT_texture_filter_anisotropic 1 + +#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + +#define GLEW_EXT_texture_filter_anisotropic GLEW_GET_VAR(__GLEW_EXT_texture_filter_anisotropic) + +#endif /* GL_EXT_texture_filter_anisotropic */ + +/* ------------------------- GL_EXT_texture_integer ------------------------ */ + +#ifndef GL_EXT_texture_integer +#define GL_EXT_texture_integer 1 + +#define GL_RGBA32UI_EXT 0x8D70 +#define GL_RGB32UI_EXT 0x8D71 +#define GL_ALPHA32UI_EXT 0x8D72 +#define GL_INTENSITY32UI_EXT 0x8D73 +#define GL_LUMINANCE32UI_EXT 0x8D74 +#define GL_LUMINANCE_ALPHA32UI_EXT 0x8D75 +#define GL_RGBA16UI_EXT 0x8D76 +#define GL_RGB16UI_EXT 0x8D77 +#define GL_ALPHA16UI_EXT 0x8D78 +#define GL_INTENSITY16UI_EXT 0x8D79 +#define GL_LUMINANCE16UI_EXT 0x8D7A +#define GL_LUMINANCE_ALPHA16UI_EXT 0x8D7B +#define GL_RGBA8UI_EXT 0x8D7C +#define GL_RGB8UI_EXT 0x8D7D +#define GL_ALPHA8UI_EXT 0x8D7E +#define GL_INTENSITY8UI_EXT 0x8D7F +#define GL_LUMINANCE8UI_EXT 0x8D80 +#define GL_LUMINANCE_ALPHA8UI_EXT 0x8D81 +#define GL_RGBA32I_EXT 0x8D82 +#define GL_RGB32I_EXT 0x8D83 +#define GL_ALPHA32I_EXT 0x8D84 +#define GL_INTENSITY32I_EXT 0x8D85 +#define GL_LUMINANCE32I_EXT 0x8D86 +#define GL_LUMINANCE_ALPHA32I_EXT 0x8D87 +#define GL_RGBA16I_EXT 0x8D88 +#define GL_RGB16I_EXT 0x8D89 +#define GL_ALPHA16I_EXT 0x8D8A +#define GL_INTENSITY16I_EXT 0x8D8B +#define GL_LUMINANCE16I_EXT 0x8D8C +#define GL_LUMINANCE_ALPHA16I_EXT 0x8D8D +#define GL_RGBA8I_EXT 0x8D8E +#define GL_RGB8I_EXT 0x8D8F +#define GL_ALPHA8I_EXT 0x8D90 +#define GL_INTENSITY8I_EXT 0x8D91 +#define GL_LUMINANCE8I_EXT 0x8D92 +#define GL_LUMINANCE_ALPHA8I_EXT 0x8D93 +#define GL_RED_INTEGER_EXT 0x8D94 +#define GL_GREEN_INTEGER_EXT 0x8D95 +#define GL_BLUE_INTEGER_EXT 0x8D96 +#define GL_ALPHA_INTEGER_EXT 0x8D97 +#define GL_RGB_INTEGER_EXT 0x8D98 +#define GL_RGBA_INTEGER_EXT 0x8D99 +#define GL_BGR_INTEGER_EXT 0x8D9A +#define GL_BGRA_INTEGER_EXT 0x8D9B +#define GL_LUMINANCE_INTEGER_EXT 0x8D9C +#define GL_LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D +#define GL_RGBA_INTEGER_MODE_EXT 0x8D9E + +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green, GLint blue, GLint alpha); +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint *params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, const GLuint *params); + +#define glClearColorIiEXT GLEW_GET_FUN(__glewClearColorIiEXT) +#define glClearColorIuiEXT GLEW_GET_FUN(__glewClearColorIuiEXT) +#define glGetTexParameterIivEXT GLEW_GET_FUN(__glewGetTexParameterIivEXT) +#define glGetTexParameterIuivEXT GLEW_GET_FUN(__glewGetTexParameterIuivEXT) +#define glTexParameterIivEXT GLEW_GET_FUN(__glewTexParameterIivEXT) +#define glTexParameterIuivEXT GLEW_GET_FUN(__glewTexParameterIuivEXT) + +#define GLEW_EXT_texture_integer GLEW_GET_VAR(__GLEW_EXT_texture_integer) + +#endif /* GL_EXT_texture_integer */ + +/* ------------------------ GL_EXT_texture_lod_bias ------------------------ */ + +#ifndef GL_EXT_texture_lod_bias +#define GL_EXT_texture_lod_bias 1 + +#define GL_MAX_TEXTURE_LOD_BIAS_EXT 0x84FD +#define GL_TEXTURE_FILTER_CONTROL_EXT 0x8500 +#define GL_TEXTURE_LOD_BIAS_EXT 0x8501 + +#define GLEW_EXT_texture_lod_bias GLEW_GET_VAR(__GLEW_EXT_texture_lod_bias) + +#endif /* GL_EXT_texture_lod_bias */ + +/* ---------------------- GL_EXT_texture_mirror_clamp ---------------------- */ + +#ifndef GL_EXT_texture_mirror_clamp +#define GL_EXT_texture_mirror_clamp 1 + +#define GL_MIRROR_CLAMP_EXT 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 +#define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 + +#define GLEW_EXT_texture_mirror_clamp GLEW_GET_VAR(__GLEW_EXT_texture_mirror_clamp) + +#endif /* GL_EXT_texture_mirror_clamp */ + +/* ------------------------- GL_EXT_texture_object ------------------------- */ + +#ifndef GL_EXT_texture_object +#define GL_EXT_texture_object 1 + +#define GL_TEXTURE_PRIORITY_EXT 0x8066 +#define GL_TEXTURE_RESIDENT_EXT 0x8067 +#define GL_TEXTURE_1D_BINDING_EXT 0x8068 +#define GL_TEXTURE_2D_BINDING_EXT 0x8069 +#define GL_TEXTURE_3D_BINDING_EXT 0x806A + +typedef GLboolean (GLAPIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint* textures, GLboolean* residences); +typedef void (GLAPIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); +typedef void (GLAPIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint* textures); +typedef void (GLAPIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint* textures); +typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture); +typedef void (GLAPIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint* textures, const GLclampf* priorities); + +#define glAreTexturesResidentEXT GLEW_GET_FUN(__glewAreTexturesResidentEXT) +#define glBindTextureEXT GLEW_GET_FUN(__glewBindTextureEXT) +#define glDeleteTexturesEXT GLEW_GET_FUN(__glewDeleteTexturesEXT) +#define glGenTexturesEXT GLEW_GET_FUN(__glewGenTexturesEXT) +#define glIsTextureEXT GLEW_GET_FUN(__glewIsTextureEXT) +#define glPrioritizeTexturesEXT GLEW_GET_FUN(__glewPrioritizeTexturesEXT) + +#define GLEW_EXT_texture_object GLEW_GET_VAR(__GLEW_EXT_texture_object) + +#endif /* GL_EXT_texture_object */ + +/* --------------------- GL_EXT_texture_perturb_normal --------------------- */ + +#ifndef GL_EXT_texture_perturb_normal +#define GL_EXT_texture_perturb_normal 1 + +#define GL_PERTURB_EXT 0x85AE +#define GL_TEXTURE_NORMAL_EXT 0x85AF + +typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); + +#define glTextureNormalEXT GLEW_GET_FUN(__glewTextureNormalEXT) + +#define GLEW_EXT_texture_perturb_normal GLEW_GET_VAR(__GLEW_EXT_texture_perturb_normal) + +#endif /* GL_EXT_texture_perturb_normal */ + +/* ------------------------ GL_EXT_texture_rectangle ----------------------- */ + +#ifndef GL_EXT_texture_rectangle +#define GL_EXT_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_EXT 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_EXT 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_EXT 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT 0x84F8 + +#define GLEW_EXT_texture_rectangle GLEW_GET_VAR(__GLEW_EXT_texture_rectangle) + +#endif /* GL_EXT_texture_rectangle */ + +/* -------------------------- GL_EXT_texture_sRGB -------------------------- */ + +#ifndef GL_EXT_texture_sRGB +#define GL_EXT_texture_sRGB 1 + +#define GL_SRGB_EXT 0x8C40 +#define GL_SRGB8_EXT 0x8C41 +#define GL_SRGB_ALPHA_EXT 0x8C42 +#define GL_SRGB8_ALPHA8_EXT 0x8C43 +#define GL_SLUMINANCE_ALPHA_EXT 0x8C44 +#define GL_SLUMINANCE8_ALPHA8_EXT 0x8C45 +#define GL_SLUMINANCE_EXT 0x8C46 +#define GL_SLUMINANCE8_EXT 0x8C47 +#define GL_COMPRESSED_SRGB_EXT 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA_EXT 0x8C49 +#define GL_COMPRESSED_SLUMINANCE_EXT 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B +#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F + +#define GLEW_EXT_texture_sRGB GLEW_GET_VAR(__GLEW_EXT_texture_sRGB) + +#endif /* GL_EXT_texture_sRGB */ + +/* ----------------------- GL_EXT_texture_sRGB_decode ---------------------- */ + +#ifndef GL_EXT_texture_sRGB_decode +#define GL_EXT_texture_sRGB_decode 1 + +#define GL_TEXTURE_SRGB_DECODE_EXT 0x8A48 +#define GL_DECODE_EXT 0x8A49 +#define GL_SKIP_DECODE_EXT 0x8A4A + +#define GLEW_EXT_texture_sRGB_decode GLEW_GET_VAR(__GLEW_EXT_texture_sRGB_decode) + +#endif /* GL_EXT_texture_sRGB_decode */ + +/* --------------------- GL_EXT_texture_shared_exponent -------------------- */ + +#ifndef GL_EXT_texture_shared_exponent +#define GL_EXT_texture_shared_exponent 1 + +#define GL_RGB9_E5_EXT 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV_EXT 0x8C3E +#define GL_TEXTURE_SHARED_SIZE_EXT 0x8C3F + +#define GLEW_EXT_texture_shared_exponent GLEW_GET_VAR(__GLEW_EXT_texture_shared_exponent) + +#endif /* GL_EXT_texture_shared_exponent */ + +/* -------------------------- GL_EXT_texture_snorm ------------------------- */ + +#ifndef GL_EXT_texture_snorm +#define GL_EXT_texture_snorm 1 + +#define GL_RED_SNORM 0x8F90 +#define GL_RG_SNORM 0x8F91 +#define GL_RGB_SNORM 0x8F92 +#define GL_RGBA_SNORM 0x8F93 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_ALPHA_SNORM 0x9010 +#define GL_LUMINANCE_SNORM 0x9011 +#define GL_LUMINANCE_ALPHA_SNORM 0x9012 +#define GL_INTENSITY_SNORM 0x9013 +#define GL_ALPHA8_SNORM 0x9014 +#define GL_LUMINANCE8_SNORM 0x9015 +#define GL_LUMINANCE8_ALPHA8_SNORM 0x9016 +#define GL_INTENSITY8_SNORM 0x9017 +#define GL_ALPHA16_SNORM 0x9018 +#define GL_LUMINANCE16_SNORM 0x9019 +#define GL_LUMINANCE16_ALPHA16_SNORM 0x901A +#define GL_INTENSITY16_SNORM 0x901B + +#define GLEW_EXT_texture_snorm GLEW_GET_VAR(__GLEW_EXT_texture_snorm) + +#endif /* GL_EXT_texture_snorm */ + +/* ------------------------- GL_EXT_texture_swizzle ------------------------ */ + +#ifndef GL_EXT_texture_swizzle +#define GL_EXT_texture_swizzle 1 + +#define GL_TEXTURE_SWIZZLE_R_EXT 0x8E42 +#define GL_TEXTURE_SWIZZLE_G_EXT 0x8E43 +#define GL_TEXTURE_SWIZZLE_B_EXT 0x8E44 +#define GL_TEXTURE_SWIZZLE_A_EXT 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA_EXT 0x8E46 + +#define GLEW_EXT_texture_swizzle GLEW_GET_VAR(__GLEW_EXT_texture_swizzle) + +#endif /* GL_EXT_texture_swizzle */ + +/* --------------------------- GL_EXT_timer_query -------------------------- */ + +#ifndef GL_EXT_timer_query +#define GL_EXT_timer_query 1 + +#define GL_TIME_ELAPSED_EXT 0x88BF + +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenum pname, GLint64EXT *params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64EXT *params); + +#define glGetQueryObjecti64vEXT GLEW_GET_FUN(__glewGetQueryObjecti64vEXT) +#define glGetQueryObjectui64vEXT GLEW_GET_FUN(__glewGetQueryObjectui64vEXT) + +#define GLEW_EXT_timer_query GLEW_GET_VAR(__GLEW_EXT_timer_query) + +#endif /* GL_EXT_timer_query */ + +/* ----------------------- GL_EXT_transform_feedback ----------------------- */ + +#ifndef GL_EXT_transform_feedback +#define GL_EXT_transform_feedback 1 + +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT 0x8C85 +#define GL_PRIMITIVES_GENERATED_EXT 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT 0x8C88 +#define GL_RASTERIZER_DISCARD_EXT 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT 0x8C8B +#define GL_INTERLEAVED_ATTRIBS_EXT 0x8C8C +#define GL_SEPARATE_ATTRIBS_EXT 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER_EXT 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT 0x8C8F + +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEEXTPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei *size, GLenum *type, char *name); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) (GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode); + +#define glBeginTransformFeedbackEXT GLEW_GET_FUN(__glewBeginTransformFeedbackEXT) +#define glBindBufferBaseEXT GLEW_GET_FUN(__glewBindBufferBaseEXT) +#define glBindBufferOffsetEXT GLEW_GET_FUN(__glewBindBufferOffsetEXT) +#define glBindBufferRangeEXT GLEW_GET_FUN(__glewBindBufferRangeEXT) +#define glEndTransformFeedbackEXT GLEW_GET_FUN(__glewEndTransformFeedbackEXT) +#define glGetTransformFeedbackVaryingEXT GLEW_GET_FUN(__glewGetTransformFeedbackVaryingEXT) +#define glTransformFeedbackVaryingsEXT GLEW_GET_FUN(__glewTransformFeedbackVaryingsEXT) + +#define GLEW_EXT_transform_feedback GLEW_GET_VAR(__GLEW_EXT_transform_feedback) + +#endif /* GL_EXT_transform_feedback */ + +/* -------------------------- GL_EXT_vertex_array -------------------------- */ + +#ifndef GL_EXT_vertex_array +#define GL_EXT_vertex_array 1 + +#define GL_DOUBLE_EXT 0x140A +#define GL_VERTEX_ARRAY_EXT 0x8074 +#define GL_NORMAL_ARRAY_EXT 0x8075 +#define GL_COLOR_ARRAY_EXT 0x8076 +#define GL_INDEX_ARRAY_EXT 0x8077 +#define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 +#define GL_EDGE_FLAG_ARRAY_EXT 0x8079 +#define GL_VERTEX_ARRAY_SIZE_EXT 0x807A +#define GL_VERTEX_ARRAY_TYPE_EXT 0x807B +#define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C +#define GL_VERTEX_ARRAY_COUNT_EXT 0x807D +#define GL_NORMAL_ARRAY_TYPE_EXT 0x807E +#define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F +#define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 +#define GL_COLOR_ARRAY_SIZE_EXT 0x8081 +#define GL_COLOR_ARRAY_TYPE_EXT 0x8082 +#define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 +#define GL_COLOR_ARRAY_COUNT_EXT 0x8084 +#define GL_INDEX_ARRAY_TYPE_EXT 0x8085 +#define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 +#define GL_INDEX_ARRAY_COUNT_EXT 0x8087 +#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A +#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B +#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C +#define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D +#define GL_VERTEX_ARRAY_POINTER_EXT 0x808E +#define GL_NORMAL_ARRAY_POINTER_EXT 0x808F +#define GL_COLOR_ARRAY_POINTER_EXT 0x8090 +#define GL_INDEX_ARRAY_POINTER_EXT 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 + +typedef void (GLAPIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i); +typedef void (GLAPIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean* pointer); +typedef void (GLAPIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); + +#define glArrayElementEXT GLEW_GET_FUN(__glewArrayElementEXT) +#define glColorPointerEXT GLEW_GET_FUN(__glewColorPointerEXT) +#define glDrawArraysEXT GLEW_GET_FUN(__glewDrawArraysEXT) +#define glEdgeFlagPointerEXT GLEW_GET_FUN(__glewEdgeFlagPointerEXT) +#define glIndexPointerEXT GLEW_GET_FUN(__glewIndexPointerEXT) +#define glNormalPointerEXT GLEW_GET_FUN(__glewNormalPointerEXT) +#define glTexCoordPointerEXT GLEW_GET_FUN(__glewTexCoordPointerEXT) +#define glVertexPointerEXT GLEW_GET_FUN(__glewVertexPointerEXT) + +#define GLEW_EXT_vertex_array GLEW_GET_VAR(__GLEW_EXT_vertex_array) + +#endif /* GL_EXT_vertex_array */ + +/* ------------------------ GL_EXT_vertex_array_bgra ----------------------- */ + +#ifndef GL_EXT_vertex_array_bgra +#define GL_EXT_vertex_array_bgra 1 + +#define GL_BGRA 0x80E1 + +#define GLEW_EXT_vertex_array_bgra GLEW_GET_VAR(__GLEW_EXT_vertex_array_bgra) + +#endif /* GL_EXT_vertex_array_bgra */ + +/* ----------------------- GL_EXT_vertex_attrib_64bit ---------------------- */ + +#ifndef GL_EXT_vertex_attrib_64bit +#define GL_EXT_vertex_attrib_64bit 1 + +#define GL_DOUBLE_MAT2_EXT 0x8F46 +#define GL_DOUBLE_MAT3_EXT 0x8F47 +#define GL_DOUBLE_MAT4_EXT 0x8F48 +#define GL_DOUBLE_MAT2x3_EXT 0x8F49 +#define GL_DOUBLE_MAT2x4_EXT 0x8F4A +#define GL_DOUBLE_MAT3x2_EXT 0x8F4B +#define GL_DOUBLE_MAT3x4_EXT 0x8F4C +#define GL_DOUBLE_MAT4x2_EXT 0x8F4D +#define GL_DOUBLE_MAT4x3_EXT 0x8F4E +#define GL_DOUBLE_VEC2_EXT 0x8FFC +#define GL_DOUBLE_VEC3_EXT 0x8FFD +#define GL_DOUBLE_VEC4_EXT 0x8FFE + +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLDVEXTPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DEXTPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DVEXTPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DEXTPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DVEXTPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DVEXTPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DVEXTPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer); + +#define glGetVertexAttribLdvEXT GLEW_GET_FUN(__glewGetVertexAttribLdvEXT) +#define glVertexArrayVertexAttribLOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribLOffsetEXT) +#define glVertexAttribL1dEXT GLEW_GET_FUN(__glewVertexAttribL1dEXT) +#define glVertexAttribL1dvEXT GLEW_GET_FUN(__glewVertexAttribL1dvEXT) +#define glVertexAttribL2dEXT GLEW_GET_FUN(__glewVertexAttribL2dEXT) +#define glVertexAttribL2dvEXT GLEW_GET_FUN(__glewVertexAttribL2dvEXT) +#define glVertexAttribL3dEXT GLEW_GET_FUN(__glewVertexAttribL3dEXT) +#define glVertexAttribL3dvEXT GLEW_GET_FUN(__glewVertexAttribL3dvEXT) +#define glVertexAttribL4dEXT GLEW_GET_FUN(__glewVertexAttribL4dEXT) +#define glVertexAttribL4dvEXT GLEW_GET_FUN(__glewVertexAttribL4dvEXT) +#define glVertexAttribLPointerEXT GLEW_GET_FUN(__glewVertexAttribLPointerEXT) + +#define GLEW_EXT_vertex_attrib_64bit GLEW_GET_VAR(__GLEW_EXT_vertex_attrib_64bit) + +#endif /* GL_EXT_vertex_attrib_64bit */ + +/* -------------------------- GL_EXT_vertex_shader ------------------------- */ + +#ifndef GL_EXT_vertex_shader +#define GL_EXT_vertex_shader 1 + +#define GL_VERTEX_SHADER_EXT 0x8780 +#define GL_VERTEX_SHADER_BINDING_EXT 0x8781 +#define GL_OP_INDEX_EXT 0x8782 +#define GL_OP_NEGATE_EXT 0x8783 +#define GL_OP_DOT3_EXT 0x8784 +#define GL_OP_DOT4_EXT 0x8785 +#define GL_OP_MUL_EXT 0x8786 +#define GL_OP_ADD_EXT 0x8787 +#define GL_OP_MADD_EXT 0x8788 +#define GL_OP_FRAC_EXT 0x8789 +#define GL_OP_MAX_EXT 0x878A +#define GL_OP_MIN_EXT 0x878B +#define GL_OP_SET_GE_EXT 0x878C +#define GL_OP_SET_LT_EXT 0x878D +#define GL_OP_CLAMP_EXT 0x878E +#define GL_OP_FLOOR_EXT 0x878F +#define GL_OP_ROUND_EXT 0x8790 +#define GL_OP_EXP_BASE_2_EXT 0x8791 +#define GL_OP_LOG_BASE_2_EXT 0x8792 +#define GL_OP_POWER_EXT 0x8793 +#define GL_OP_RECIP_EXT 0x8794 +#define GL_OP_RECIP_SQRT_EXT 0x8795 +#define GL_OP_SUB_EXT 0x8796 +#define GL_OP_CROSS_PRODUCT_EXT 0x8797 +#define GL_OP_MULTIPLY_MATRIX_EXT 0x8798 +#define GL_OP_MOV_EXT 0x8799 +#define GL_OUTPUT_VERTEX_EXT 0x879A +#define GL_OUTPUT_COLOR0_EXT 0x879B +#define GL_OUTPUT_COLOR1_EXT 0x879C +#define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D +#define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E +#define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F +#define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0 +#define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1 +#define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2 +#define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3 +#define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4 +#define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5 +#define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6 +#define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7 +#define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8 +#define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9 +#define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA +#define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB +#define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC +#define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD +#define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE +#define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF +#define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0 +#define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1 +#define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2 +#define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3 +#define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4 +#define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5 +#define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6 +#define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7 +#define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8 +#define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9 +#define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA +#define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB +#define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC +#define GL_OUTPUT_FOG_EXT 0x87BD +#define GL_SCALAR_EXT 0x87BE +#define GL_VECTOR_EXT 0x87BF +#define GL_MATRIX_EXT 0x87C0 +#define GL_VARIANT_EXT 0x87C1 +#define GL_INVARIANT_EXT 0x87C2 +#define GL_LOCAL_CONSTANT_EXT 0x87C3 +#define GL_LOCAL_EXT 0x87C4 +#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5 +#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6 +#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7 +#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8 +#define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9 +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CC +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CD +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE +#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF +#define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0 +#define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1 +#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2 +#define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3 +#define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4 +#define GL_X_EXT 0x87D5 +#define GL_Y_EXT 0x87D6 +#define GL_Z_EXT 0x87D7 +#define GL_W_EXT 0x87D8 +#define GL_NEGATIVE_X_EXT 0x87D9 +#define GL_NEGATIVE_Y_EXT 0x87DA +#define GL_NEGATIVE_Z_EXT 0x87DB +#define GL_NEGATIVE_W_EXT 0x87DC +#define GL_ZERO_EXT 0x87DD +#define GL_ONE_EXT 0x87DE +#define GL_NEGATIVE_ONE_EXT 0x87DF +#define GL_NORMALIZED_RANGE_EXT 0x87E0 +#define GL_FULL_RANGE_EXT 0x87E1 +#define GL_CURRENT_VERTEX_EXT 0x87E2 +#define GL_MVP_MATRIX_EXT 0x87E3 +#define GL_VARIANT_VALUE_EXT 0x87E4 +#define GL_VARIANT_DATATYPE_EXT 0x87E5 +#define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6 +#define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7 +#define GL_VARIANT_ARRAY_EXT 0x87E8 +#define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9 +#define GL_INVARIANT_VALUE_EXT 0x87EA +#define GL_INVARIANT_DATATYPE_EXT 0x87EB +#define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC +#define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED + +typedef void (GLAPIENTRY * PFNGLBEGINVERTEXSHADEREXTPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDPARAMETEREXTPROC) (GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value); +typedef void (GLAPIENTRY * PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENDVERTEXSHADEREXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef GLuint (GLAPIENTRY * PFNGLGENSYMBOLSEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components); +typedef GLuint (GLAPIENTRY * PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid **data); +typedef void (GLAPIENTRY * PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef GLboolean (GLAPIENTRY * PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap); +typedef void (GLAPIENTRY * PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1); +typedef void (GLAPIENTRY * PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2); +typedef void (GLAPIENTRY * PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); +typedef void (GLAPIENTRY * PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); +typedef void (GLAPIENTRY * PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTBVEXTPROC) (GLuint id, GLbyte *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTDVEXTPROC) (GLuint id, GLdouble *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTFVEXTPROC) (GLuint id, GLfloat *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTIVEXTPROC) (GLuint id, GLint *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTSVEXTPROC) (GLuint id, GLshort *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUBVEXTPROC) (GLuint id, GLubyte *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUIVEXTPROC) (GLuint id, GLuint *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUSVEXTPROC) (GLuint id, GLushort *addr); +typedef void (GLAPIENTRY * PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); + +#define glBeginVertexShaderEXT GLEW_GET_FUN(__glewBeginVertexShaderEXT) +#define glBindLightParameterEXT GLEW_GET_FUN(__glewBindLightParameterEXT) +#define glBindMaterialParameterEXT GLEW_GET_FUN(__glewBindMaterialParameterEXT) +#define glBindParameterEXT GLEW_GET_FUN(__glewBindParameterEXT) +#define glBindTexGenParameterEXT GLEW_GET_FUN(__glewBindTexGenParameterEXT) +#define glBindTextureUnitParameterEXT GLEW_GET_FUN(__glewBindTextureUnitParameterEXT) +#define glBindVertexShaderEXT GLEW_GET_FUN(__glewBindVertexShaderEXT) +#define glDeleteVertexShaderEXT GLEW_GET_FUN(__glewDeleteVertexShaderEXT) +#define glDisableVariantClientStateEXT GLEW_GET_FUN(__glewDisableVariantClientStateEXT) +#define glEnableVariantClientStateEXT GLEW_GET_FUN(__glewEnableVariantClientStateEXT) +#define glEndVertexShaderEXT GLEW_GET_FUN(__glewEndVertexShaderEXT) +#define glExtractComponentEXT GLEW_GET_FUN(__glewExtractComponentEXT) +#define glGenSymbolsEXT GLEW_GET_FUN(__glewGenSymbolsEXT) +#define glGenVertexShadersEXT GLEW_GET_FUN(__glewGenVertexShadersEXT) +#define glGetInvariantBooleanvEXT GLEW_GET_FUN(__glewGetInvariantBooleanvEXT) +#define glGetInvariantFloatvEXT GLEW_GET_FUN(__glewGetInvariantFloatvEXT) +#define glGetInvariantIntegervEXT GLEW_GET_FUN(__glewGetInvariantIntegervEXT) +#define glGetLocalConstantBooleanvEXT GLEW_GET_FUN(__glewGetLocalConstantBooleanvEXT) +#define glGetLocalConstantFloatvEXT GLEW_GET_FUN(__glewGetLocalConstantFloatvEXT) +#define glGetLocalConstantIntegervEXT GLEW_GET_FUN(__glewGetLocalConstantIntegervEXT) +#define glGetVariantBooleanvEXT GLEW_GET_FUN(__glewGetVariantBooleanvEXT) +#define glGetVariantFloatvEXT GLEW_GET_FUN(__glewGetVariantFloatvEXT) +#define glGetVariantIntegervEXT GLEW_GET_FUN(__glewGetVariantIntegervEXT) +#define glGetVariantPointervEXT GLEW_GET_FUN(__glewGetVariantPointervEXT) +#define glInsertComponentEXT GLEW_GET_FUN(__glewInsertComponentEXT) +#define glIsVariantEnabledEXT GLEW_GET_FUN(__glewIsVariantEnabledEXT) +#define glSetInvariantEXT GLEW_GET_FUN(__glewSetInvariantEXT) +#define glSetLocalConstantEXT GLEW_GET_FUN(__glewSetLocalConstantEXT) +#define glShaderOp1EXT GLEW_GET_FUN(__glewShaderOp1EXT) +#define glShaderOp2EXT GLEW_GET_FUN(__glewShaderOp2EXT) +#define glShaderOp3EXT GLEW_GET_FUN(__glewShaderOp3EXT) +#define glSwizzleEXT GLEW_GET_FUN(__glewSwizzleEXT) +#define glVariantPointerEXT GLEW_GET_FUN(__glewVariantPointerEXT) +#define glVariantbvEXT GLEW_GET_FUN(__glewVariantbvEXT) +#define glVariantdvEXT GLEW_GET_FUN(__glewVariantdvEXT) +#define glVariantfvEXT GLEW_GET_FUN(__glewVariantfvEXT) +#define glVariantivEXT GLEW_GET_FUN(__glewVariantivEXT) +#define glVariantsvEXT GLEW_GET_FUN(__glewVariantsvEXT) +#define glVariantubvEXT GLEW_GET_FUN(__glewVariantubvEXT) +#define glVariantuivEXT GLEW_GET_FUN(__glewVariantuivEXT) +#define glVariantusvEXT GLEW_GET_FUN(__glewVariantusvEXT) +#define glWriteMaskEXT GLEW_GET_FUN(__glewWriteMaskEXT) + +#define GLEW_EXT_vertex_shader GLEW_GET_VAR(__GLEW_EXT_vertex_shader) + +#endif /* GL_EXT_vertex_shader */ + +/* ------------------------ GL_EXT_vertex_weighting ------------------------ */ + +#ifndef GL_EXT_vertex_weighting +#define GL_EXT_vertex_weighting 1 + +#define GL_MODELVIEW0_STACK_DEPTH_EXT 0x0BA3 +#define GL_MODELVIEW0_MATRIX_EXT 0x0BA6 +#define GL_MODELVIEW0_EXT 0x1700 +#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 +#define GL_MODELVIEW1_MATRIX_EXT 0x8506 +#define GL_VERTEX_WEIGHTING_EXT 0x8509 +#define GL_MODELVIEW1_EXT 0x850A +#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B +#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C +#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D +#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E +#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F +#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 + +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (GLfloat* weight); + +#define glVertexWeightPointerEXT GLEW_GET_FUN(__glewVertexWeightPointerEXT) +#define glVertexWeightfEXT GLEW_GET_FUN(__glewVertexWeightfEXT) +#define glVertexWeightfvEXT GLEW_GET_FUN(__glewVertexWeightfvEXT) + +#define GLEW_EXT_vertex_weighting GLEW_GET_VAR(__GLEW_EXT_vertex_weighting) + +#endif /* GL_EXT_vertex_weighting */ + +/* ------------------------- GL_EXT_x11_sync_object ------------------------ */ + +#ifndef GL_EXT_x11_sync_object +#define GL_EXT_x11_sync_object 1 + +#define GL_SYNC_X11_FENCE_EXT 0x90E1 + +typedef GLsync (GLAPIENTRY * PFNGLIMPORTSYNCEXTPROC) (GLenum external_sync_type, GLintptr external_sync, GLbitfield flags); + +#define glImportSyncEXT GLEW_GET_FUN(__glewImportSyncEXT) + +#define GLEW_EXT_x11_sync_object GLEW_GET_VAR(__GLEW_EXT_x11_sync_object) + +#endif /* GL_EXT_x11_sync_object */ + +/* ---------------------- GL_GREMEDY_frame_terminator ---------------------- */ + +#ifndef GL_GREMEDY_frame_terminator +#define GL_GREMEDY_frame_terminator 1 + +typedef void (GLAPIENTRY * PFNGLFRAMETERMINATORGREMEDYPROC) (void); + +#define glFrameTerminatorGREMEDY GLEW_GET_FUN(__glewFrameTerminatorGREMEDY) + +#define GLEW_GREMEDY_frame_terminator GLEW_GET_VAR(__GLEW_GREMEDY_frame_terminator) + +#endif /* GL_GREMEDY_frame_terminator */ + +/* ------------------------ GL_GREMEDY_string_marker ----------------------- */ + +#ifndef GL_GREMEDY_string_marker +#define GL_GREMEDY_string_marker 1 + +typedef void (GLAPIENTRY * PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const void* string); + +#define glStringMarkerGREMEDY GLEW_GET_FUN(__glewStringMarkerGREMEDY) + +#define GLEW_GREMEDY_string_marker GLEW_GET_VAR(__GLEW_GREMEDY_string_marker) + +#endif /* GL_GREMEDY_string_marker */ + +/* --------------------- GL_HP_convolution_border_modes -------------------- */ + +#ifndef GL_HP_convolution_border_modes +#define GL_HP_convolution_border_modes 1 + +#define GLEW_HP_convolution_border_modes GLEW_GET_VAR(__GLEW_HP_convolution_border_modes) + +#endif /* GL_HP_convolution_border_modes */ + +/* ------------------------- GL_HP_image_transform ------------------------- */ + +#ifndef GL_HP_image_transform +#define GL_HP_image_transform 1 + +typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glGetImageTransformParameterfvHP GLEW_GET_FUN(__glewGetImageTransformParameterfvHP) +#define glGetImageTransformParameterivHP GLEW_GET_FUN(__glewGetImageTransformParameterivHP) +#define glImageTransformParameterfHP GLEW_GET_FUN(__glewImageTransformParameterfHP) +#define glImageTransformParameterfvHP GLEW_GET_FUN(__glewImageTransformParameterfvHP) +#define glImageTransformParameteriHP GLEW_GET_FUN(__glewImageTransformParameteriHP) +#define glImageTransformParameterivHP GLEW_GET_FUN(__glewImageTransformParameterivHP) + +#define GLEW_HP_image_transform GLEW_GET_VAR(__GLEW_HP_image_transform) + +#endif /* GL_HP_image_transform */ + +/* -------------------------- GL_HP_occlusion_test ------------------------- */ + +#ifndef GL_HP_occlusion_test +#define GL_HP_occlusion_test 1 + +#define GL_OCCLUSION_TEST_HP 0x8165 +#define GL_OCCLUSION_TEST_RESULT_HP 0x8166 + +#define GLEW_HP_occlusion_test GLEW_GET_VAR(__GLEW_HP_occlusion_test) + +#endif /* GL_HP_occlusion_test */ + +/* ------------------------- GL_HP_texture_lighting ------------------------ */ + +#ifndef GL_HP_texture_lighting +#define GL_HP_texture_lighting 1 + +#define GLEW_HP_texture_lighting GLEW_GET_VAR(__GLEW_HP_texture_lighting) + +#endif /* GL_HP_texture_lighting */ + +/* --------------------------- GL_IBM_cull_vertex -------------------------- */ + +#ifndef GL_IBM_cull_vertex +#define GL_IBM_cull_vertex 1 + +#define GL_CULL_VERTEX_IBM 103050 + +#define GLEW_IBM_cull_vertex GLEW_GET_VAR(__GLEW_IBM_cull_vertex) + +#endif /* GL_IBM_cull_vertex */ + +/* ---------------------- GL_IBM_multimode_draw_arrays --------------------- */ + +#ifndef GL_IBM_multimode_draw_arrays +#define GL_IBM_multimode_draw_arrays 1 + +typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum* mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride); +typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum* mode, const GLsizei *count, GLenum type, const GLvoid * const *indices, GLsizei primcount, GLint modestride); + +#define glMultiModeDrawArraysIBM GLEW_GET_FUN(__glewMultiModeDrawArraysIBM) +#define glMultiModeDrawElementsIBM GLEW_GET_FUN(__glewMultiModeDrawElementsIBM) + +#define GLEW_IBM_multimode_draw_arrays GLEW_GET_VAR(__GLEW_IBM_multimode_draw_arrays) + +#endif /* GL_IBM_multimode_draw_arrays */ + +/* ------------------------- GL_IBM_rasterpos_clip ------------------------- */ + +#ifndef GL_IBM_rasterpos_clip +#define GL_IBM_rasterpos_clip 1 + +#define GL_RASTER_POSITION_UNCLIPPED_IBM 103010 + +#define GLEW_IBM_rasterpos_clip GLEW_GET_VAR(__GLEW_IBM_rasterpos_clip) + +#endif /* GL_IBM_rasterpos_clip */ + +/* --------------------------- GL_IBM_static_data -------------------------- */ + +#ifndef GL_IBM_static_data +#define GL_IBM_static_data 1 + +#define GL_ALL_STATIC_DATA_IBM 103060 +#define GL_STATIC_VERTEX_ARRAY_IBM 103061 + +#define GLEW_IBM_static_data GLEW_GET_VAR(__GLEW_IBM_static_data) + +#endif /* GL_IBM_static_data */ + +/* --------------------- GL_IBM_texture_mirrored_repeat -------------------- */ + +#ifndef GL_IBM_texture_mirrored_repeat +#define GL_IBM_texture_mirrored_repeat 1 + +#define GL_MIRRORED_REPEAT_IBM 0x8370 + +#define GLEW_IBM_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_IBM_texture_mirrored_repeat) + +#endif /* GL_IBM_texture_mirrored_repeat */ + +/* ----------------------- GL_IBM_vertex_array_lists ----------------------- */ + +#ifndef GL_IBM_vertex_array_lists +#define GL_IBM_vertex_array_lists 1 + +#define GL_VERTEX_ARRAY_LIST_IBM 103070 +#define GL_NORMAL_ARRAY_LIST_IBM 103071 +#define GL_COLOR_ARRAY_LIST_IBM 103072 +#define GL_INDEX_ARRAY_LIST_IBM 103073 +#define GL_TEXTURE_COORD_ARRAY_LIST_IBM 103074 +#define GL_EDGE_FLAG_ARRAY_LIST_IBM 103075 +#define GL_FOG_COORDINATE_ARRAY_LIST_IBM 103076 +#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077 +#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM 103080 +#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM 103081 +#define GL_COLOR_ARRAY_LIST_STRIDE_IBM 103082 +#define GL_INDEX_ARRAY_LIST_STRIDE_IBM 103083 +#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084 +#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085 +#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086 +#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087 + +typedef void (GLAPIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); + +#define glColorPointerListIBM GLEW_GET_FUN(__glewColorPointerListIBM) +#define glEdgeFlagPointerListIBM GLEW_GET_FUN(__glewEdgeFlagPointerListIBM) +#define glFogCoordPointerListIBM GLEW_GET_FUN(__glewFogCoordPointerListIBM) +#define glIndexPointerListIBM GLEW_GET_FUN(__glewIndexPointerListIBM) +#define glNormalPointerListIBM GLEW_GET_FUN(__glewNormalPointerListIBM) +#define glSecondaryColorPointerListIBM GLEW_GET_FUN(__glewSecondaryColorPointerListIBM) +#define glTexCoordPointerListIBM GLEW_GET_FUN(__glewTexCoordPointerListIBM) +#define glVertexPointerListIBM GLEW_GET_FUN(__glewVertexPointerListIBM) + +#define GLEW_IBM_vertex_array_lists GLEW_GET_VAR(__GLEW_IBM_vertex_array_lists) + +#endif /* GL_IBM_vertex_array_lists */ + +/* -------------------------- GL_INGR_color_clamp -------------------------- */ + +#ifndef GL_INGR_color_clamp +#define GL_INGR_color_clamp 1 + +#define GL_RED_MIN_CLAMP_INGR 0x8560 +#define GL_GREEN_MIN_CLAMP_INGR 0x8561 +#define GL_BLUE_MIN_CLAMP_INGR 0x8562 +#define GL_ALPHA_MIN_CLAMP_INGR 0x8563 +#define GL_RED_MAX_CLAMP_INGR 0x8564 +#define GL_GREEN_MAX_CLAMP_INGR 0x8565 +#define GL_BLUE_MAX_CLAMP_INGR 0x8566 +#define GL_ALPHA_MAX_CLAMP_INGR 0x8567 + +#define GLEW_INGR_color_clamp GLEW_GET_VAR(__GLEW_INGR_color_clamp) + +#endif /* GL_INGR_color_clamp */ + +/* ------------------------- GL_INGR_interlace_read ------------------------ */ + +#ifndef GL_INGR_interlace_read +#define GL_INGR_interlace_read 1 + +#define GL_INTERLACE_READ_INGR 0x8568 + +#define GLEW_INGR_interlace_read GLEW_GET_VAR(__GLEW_INGR_interlace_read) + +#endif /* GL_INGR_interlace_read */ + +/* ------------------------ GL_INTEL_parallel_arrays ----------------------- */ + +#ifndef GL_INTEL_parallel_arrays +#define GL_INTEL_parallel_arrays 1 + +#define GL_PARALLEL_ARRAYS_INTEL 0x83F4 +#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5 +#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6 +#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7 +#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8 + +typedef void (GLAPIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); + +#define glColorPointervINTEL GLEW_GET_FUN(__glewColorPointervINTEL) +#define glNormalPointervINTEL GLEW_GET_FUN(__glewNormalPointervINTEL) +#define glTexCoordPointervINTEL GLEW_GET_FUN(__glewTexCoordPointervINTEL) +#define glVertexPointervINTEL GLEW_GET_FUN(__glewVertexPointervINTEL) + +#define GLEW_INTEL_parallel_arrays GLEW_GET_VAR(__GLEW_INTEL_parallel_arrays) + +#endif /* GL_INTEL_parallel_arrays */ + +/* ------------------------ GL_INTEL_texture_scissor ----------------------- */ + +#ifndef GL_INTEL_texture_scissor +#define GL_INTEL_texture_scissor 1 + +typedef void (GLAPIENTRY * PFNGLTEXSCISSORFUNCINTELPROC) (GLenum target, GLenum lfunc, GLenum hfunc); +typedef void (GLAPIENTRY * PFNGLTEXSCISSORINTELPROC) (GLenum target, GLclampf tlow, GLclampf thigh); + +#define glTexScissorFuncINTEL GLEW_GET_FUN(__glewTexScissorFuncINTEL) +#define glTexScissorINTEL GLEW_GET_FUN(__glewTexScissorINTEL) + +#define GLEW_INTEL_texture_scissor GLEW_GET_VAR(__GLEW_INTEL_texture_scissor) + +#endif /* GL_INTEL_texture_scissor */ + +/* -------------------------- GL_KTX_buffer_region ------------------------- */ + +#ifndef GL_KTX_buffer_region +#define GL_KTX_buffer_region 1 + +#define GL_KTX_FRONT_REGION 0x0 +#define GL_KTX_BACK_REGION 0x1 +#define GL_KTX_Z_REGION 0x2 +#define GL_KTX_STENCIL_REGION 0x3 + +typedef GLuint (GLAPIENTRY * PFNGLBUFFERREGIONENABLEDPROC) (void); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERREGIONPROC) (GLenum region); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERREGIONPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest); +typedef GLuint (GLAPIENTRY * PFNGLNEWBUFFERREGIONPROC) (GLenum region); +typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height); + +#define glBufferRegionEnabled GLEW_GET_FUN(__glewBufferRegionEnabled) +#define glDeleteBufferRegion GLEW_GET_FUN(__glewDeleteBufferRegion) +#define glDrawBufferRegion GLEW_GET_FUN(__glewDrawBufferRegion) +#define glNewBufferRegion GLEW_GET_FUN(__glewNewBufferRegion) +#define glReadBufferRegion GLEW_GET_FUN(__glewReadBufferRegion) + +#define GLEW_KTX_buffer_region GLEW_GET_VAR(__GLEW_KTX_buffer_region) + +#endif /* GL_KTX_buffer_region */ + +/* ------------------------- GL_MESAX_texture_stack ------------------------ */ + +#ifndef GL_MESAX_texture_stack +#define GL_MESAX_texture_stack 1 + +#define GL_TEXTURE_1D_STACK_MESAX 0x8759 +#define GL_TEXTURE_2D_STACK_MESAX 0x875A +#define GL_PROXY_TEXTURE_1D_STACK_MESAX 0x875B +#define GL_PROXY_TEXTURE_2D_STACK_MESAX 0x875C +#define GL_TEXTURE_1D_STACK_BINDING_MESAX 0x875D +#define GL_TEXTURE_2D_STACK_BINDING_MESAX 0x875E + +#define GLEW_MESAX_texture_stack GLEW_GET_VAR(__GLEW_MESAX_texture_stack) + +#endif /* GL_MESAX_texture_stack */ + +/* -------------------------- GL_MESA_pack_invert -------------------------- */ + +#ifndef GL_MESA_pack_invert +#define GL_MESA_pack_invert 1 + +#define GL_PACK_INVERT_MESA 0x8758 + +#define GLEW_MESA_pack_invert GLEW_GET_VAR(__GLEW_MESA_pack_invert) + +#endif /* GL_MESA_pack_invert */ + +/* ------------------------- GL_MESA_resize_buffers ------------------------ */ + +#ifndef GL_MESA_resize_buffers +#define GL_MESA_resize_buffers 1 + +typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void); + +#define glResizeBuffersMESA GLEW_GET_FUN(__glewResizeBuffersMESA) + +#define GLEW_MESA_resize_buffers GLEW_GET_VAR(__GLEW_MESA_resize_buffers) + +#endif /* GL_MESA_resize_buffers */ + +/* --------------------------- GL_MESA_window_pos -------------------------- */ + +#ifndef GL_MESA_window_pos +#define GL_MESA_window_pos 1 + +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort* p); + +#define glWindowPos2dMESA GLEW_GET_FUN(__glewWindowPos2dMESA) +#define glWindowPos2dvMESA GLEW_GET_FUN(__glewWindowPos2dvMESA) +#define glWindowPos2fMESA GLEW_GET_FUN(__glewWindowPos2fMESA) +#define glWindowPos2fvMESA GLEW_GET_FUN(__glewWindowPos2fvMESA) +#define glWindowPos2iMESA GLEW_GET_FUN(__glewWindowPos2iMESA) +#define glWindowPos2ivMESA GLEW_GET_FUN(__glewWindowPos2ivMESA) +#define glWindowPos2sMESA GLEW_GET_FUN(__glewWindowPos2sMESA) +#define glWindowPos2svMESA GLEW_GET_FUN(__glewWindowPos2svMESA) +#define glWindowPos3dMESA GLEW_GET_FUN(__glewWindowPos3dMESA) +#define glWindowPos3dvMESA GLEW_GET_FUN(__glewWindowPos3dvMESA) +#define glWindowPos3fMESA GLEW_GET_FUN(__glewWindowPos3fMESA) +#define glWindowPos3fvMESA GLEW_GET_FUN(__glewWindowPos3fvMESA) +#define glWindowPos3iMESA GLEW_GET_FUN(__glewWindowPos3iMESA) +#define glWindowPos3ivMESA GLEW_GET_FUN(__glewWindowPos3ivMESA) +#define glWindowPos3sMESA GLEW_GET_FUN(__glewWindowPos3sMESA) +#define glWindowPos3svMESA GLEW_GET_FUN(__glewWindowPos3svMESA) +#define glWindowPos4dMESA GLEW_GET_FUN(__glewWindowPos4dMESA) +#define glWindowPos4dvMESA GLEW_GET_FUN(__glewWindowPos4dvMESA) +#define glWindowPos4fMESA GLEW_GET_FUN(__glewWindowPos4fMESA) +#define glWindowPos4fvMESA GLEW_GET_FUN(__glewWindowPos4fvMESA) +#define glWindowPos4iMESA GLEW_GET_FUN(__glewWindowPos4iMESA) +#define glWindowPos4ivMESA GLEW_GET_FUN(__glewWindowPos4ivMESA) +#define glWindowPos4sMESA GLEW_GET_FUN(__glewWindowPos4sMESA) +#define glWindowPos4svMESA GLEW_GET_FUN(__glewWindowPos4svMESA) + +#define GLEW_MESA_window_pos GLEW_GET_VAR(__GLEW_MESA_window_pos) + +#endif /* GL_MESA_window_pos */ + +/* ------------------------- GL_MESA_ycbcr_texture ------------------------- */ + +#ifndef GL_MESA_ycbcr_texture +#define GL_MESA_ycbcr_texture 1 + +#define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB +#define GL_YCBCR_MESA 0x8757 + +#define GLEW_MESA_ycbcr_texture GLEW_GET_VAR(__GLEW_MESA_ycbcr_texture) + +#endif /* GL_MESA_ycbcr_texture */ + +/* ------------------------- GL_NVX_gpu_memory_info ------------------------ */ + +#ifndef GL_NVX_gpu_memory_info +#define GL_NVX_gpu_memory_info 1 + +#define GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX 0x9047 +#define GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX 0x9048 +#define GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX 0x9049 +#define GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX 0x904A +#define GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX 0x904B + +#define GLEW_NVX_gpu_memory_info GLEW_GET_VAR(__GLEW_NVX_gpu_memory_info) + +#endif /* GL_NVX_gpu_memory_info */ + +/* --------------------------- GL_NV_blend_square -------------------------- */ + +#ifndef GL_NV_blend_square +#define GL_NV_blend_square 1 + +#define GLEW_NV_blend_square GLEW_GET_VAR(__GLEW_NV_blend_square) + +#endif /* GL_NV_blend_square */ + +/* ------------------------ GL_NV_conditional_render ----------------------- */ + +#ifndef GL_NV_conditional_render +#define GL_NV_conditional_render 1 + +#define GL_QUERY_WAIT_NV 0x8E13 +#define GL_QUERY_NO_WAIT_NV 0x8E14 +#define GL_QUERY_BY_REGION_WAIT_NV 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT_NV 0x8E16 + +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERNVPROC) (GLuint id, GLenum mode); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVPROC) (void); + +#define glBeginConditionalRenderNV GLEW_GET_FUN(__glewBeginConditionalRenderNV) +#define glEndConditionalRenderNV GLEW_GET_FUN(__glewEndConditionalRenderNV) + +#define GLEW_NV_conditional_render GLEW_GET_VAR(__GLEW_NV_conditional_render) + +#endif /* GL_NV_conditional_render */ + +/* ----------------------- GL_NV_copy_depth_to_color ----------------------- */ + +#ifndef GL_NV_copy_depth_to_color +#define GL_NV_copy_depth_to_color 1 + +#define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E +#define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F + +#define GLEW_NV_copy_depth_to_color GLEW_GET_VAR(__GLEW_NV_copy_depth_to_color) + +#endif /* GL_NV_copy_depth_to_color */ + +/* ---------------------------- GL_NV_copy_image --------------------------- */ + +#ifndef GL_NV_copy_image +#define GL_NV_copy_image 1 + +typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATANVPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); + +#define glCopyImageSubDataNV GLEW_GET_FUN(__glewCopyImageSubDataNV) + +#define GLEW_NV_copy_image GLEW_GET_VAR(__GLEW_NV_copy_image) + +#endif /* GL_NV_copy_image */ + +/* ------------------------ GL_NV_depth_buffer_float ----------------------- */ + +#ifndef GL_NV_depth_buffer_float +#define GL_NV_depth_buffer_float 1 + +#define GL_DEPTH_COMPONENT32F_NV 0x8DAB +#define GL_DEPTH32F_STENCIL8_NV 0x8DAC +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV 0x8DAD +#define GL_DEPTH_BUFFER_FLOAT_MODE_NV 0x8DAF + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHDNVPROC) (GLdouble depth); +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble zmax); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFar); + +#define glClearDepthdNV GLEW_GET_FUN(__glewClearDepthdNV) +#define glDepthBoundsdNV GLEW_GET_FUN(__glewDepthBoundsdNV) +#define glDepthRangedNV GLEW_GET_FUN(__glewDepthRangedNV) + +#define GLEW_NV_depth_buffer_float GLEW_GET_VAR(__GLEW_NV_depth_buffer_float) + +#endif /* GL_NV_depth_buffer_float */ + +/* --------------------------- GL_NV_depth_clamp --------------------------- */ + +#ifndef GL_NV_depth_clamp +#define GL_NV_depth_clamp 1 + +#define GL_DEPTH_CLAMP_NV 0x864F + +#define GLEW_NV_depth_clamp GLEW_GET_VAR(__GLEW_NV_depth_clamp) + +#endif /* GL_NV_depth_clamp */ + +/* ---------------------- GL_NV_depth_range_unclamped ---------------------- */ + +#ifndef GL_NV_depth_range_unclamped +#define GL_NV_depth_range_unclamped 1 + +#define GL_SAMPLE_COUNT_BITS_NV 0x8864 +#define GL_CURRENT_SAMPLE_COUNT_QUERY_NV 0x8865 +#define GL_QUERY_RESULT_NV 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_NV 0x8867 +#define GL_SAMPLE_COUNT_NV 0x8914 + +#define GLEW_NV_depth_range_unclamped GLEW_GET_VAR(__GLEW_NV_depth_range_unclamped) + +#endif /* GL_NV_depth_range_unclamped */ + +/* ---------------------------- GL_NV_evaluators --------------------------- */ + +#ifndef GL_NV_evaluators +#define GL_NV_evaluators 1 + +#define GL_EVAL_2D_NV 0x86C0 +#define GL_EVAL_TRIANGULAR_2D_NV 0x86C1 +#define GL_MAP_TESSELLATION_NV 0x86C2 +#define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3 +#define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4 +#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5 +#define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6 +#define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7 +#define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8 +#define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9 +#define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA +#define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB +#define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC +#define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD +#define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE +#define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF +#define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0 +#define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1 +#define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2 +#define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3 +#define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4 +#define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5 +#define GL_MAX_MAP_TESSELLATION_NV 0x86D6 +#define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7 + +typedef void (GLAPIENTRY * PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode); +typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void* points); +typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void* points); +typedef void (GLAPIENTRY * PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glEvalMapsNV GLEW_GET_FUN(__glewEvalMapsNV) +#define glGetMapAttribParameterfvNV GLEW_GET_FUN(__glewGetMapAttribParameterfvNV) +#define glGetMapAttribParameterivNV GLEW_GET_FUN(__glewGetMapAttribParameterivNV) +#define glGetMapControlPointsNV GLEW_GET_FUN(__glewGetMapControlPointsNV) +#define glGetMapParameterfvNV GLEW_GET_FUN(__glewGetMapParameterfvNV) +#define glGetMapParameterivNV GLEW_GET_FUN(__glewGetMapParameterivNV) +#define glMapControlPointsNV GLEW_GET_FUN(__glewMapControlPointsNV) +#define glMapParameterfvNV GLEW_GET_FUN(__glewMapParameterfvNV) +#define glMapParameterivNV GLEW_GET_FUN(__glewMapParameterivNV) + +#define GLEW_NV_evaluators GLEW_GET_VAR(__GLEW_NV_evaluators) + +#endif /* GL_NV_evaluators */ + +/* ----------------------- GL_NV_explicit_multisample ---------------------- */ + +#ifndef GL_NV_explicit_multisample +#define GL_NV_explicit_multisample 1 + +#define GL_SAMPLE_POSITION_NV 0x8E50 +#define GL_SAMPLE_MASK_NV 0x8E51 +#define GL_SAMPLE_MASK_VALUE_NV 0x8E52 +#define GL_TEXTURE_BINDING_RENDERBUFFER_NV 0x8E53 +#define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV 0x8E54 +#define GL_TEXTURE_RENDERBUFFER_NV 0x8E55 +#define GL_SAMPLER_RENDERBUFFER_NV 0x8E56 +#define GL_INT_SAMPLER_RENDERBUFFER_NV 0x8E57 +#define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV 0x8E58 +#define GL_MAX_SAMPLE_MASK_WORDS_NV 0x8E59 + +typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVNVPROC) (GLenum pname, GLuint index, GLfloat* val); +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKINDEXEDNVPROC) (GLuint index, GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint renderbuffer); + +#define glGetMultisamplefvNV GLEW_GET_FUN(__glewGetMultisamplefvNV) +#define glSampleMaskIndexedNV GLEW_GET_FUN(__glewSampleMaskIndexedNV) +#define glTexRenderbufferNV GLEW_GET_FUN(__glewTexRenderbufferNV) + +#define GLEW_NV_explicit_multisample GLEW_GET_VAR(__GLEW_NV_explicit_multisample) + +#endif /* GL_NV_explicit_multisample */ + +/* ------------------------------ GL_NV_fence ------------------------------ */ + +#ifndef GL_NV_fence +#define GL_NV_fence 1 + +#define GL_ALL_COMPLETED_NV 0x84F2 +#define GL_FENCE_STATUS_NV 0x84F3 +#define GL_FENCE_CONDITION_NV 0x84F4 + +typedef void (GLAPIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint* fences); +typedef void (GLAPIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint* fences); +typedef void (GLAPIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); +typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence); + +#define glDeleteFencesNV GLEW_GET_FUN(__glewDeleteFencesNV) +#define glFinishFenceNV GLEW_GET_FUN(__glewFinishFenceNV) +#define glGenFencesNV GLEW_GET_FUN(__glewGenFencesNV) +#define glGetFenceivNV GLEW_GET_FUN(__glewGetFenceivNV) +#define glIsFenceNV GLEW_GET_FUN(__glewIsFenceNV) +#define glSetFenceNV GLEW_GET_FUN(__glewSetFenceNV) +#define glTestFenceNV GLEW_GET_FUN(__glewTestFenceNV) + +#define GLEW_NV_fence GLEW_GET_VAR(__GLEW_NV_fence) + +#endif /* GL_NV_fence */ + +/* --------------------------- GL_NV_float_buffer -------------------------- */ + +#ifndef GL_NV_float_buffer +#define GL_NV_float_buffer 1 + +#define GL_FLOAT_R_NV 0x8880 +#define GL_FLOAT_RG_NV 0x8881 +#define GL_FLOAT_RGB_NV 0x8882 +#define GL_FLOAT_RGBA_NV 0x8883 +#define GL_FLOAT_R16_NV 0x8884 +#define GL_FLOAT_R32_NV 0x8885 +#define GL_FLOAT_RG16_NV 0x8886 +#define GL_FLOAT_RG32_NV 0x8887 +#define GL_FLOAT_RGB16_NV 0x8888 +#define GL_FLOAT_RGB32_NV 0x8889 +#define GL_FLOAT_RGBA16_NV 0x888A +#define GL_FLOAT_RGBA32_NV 0x888B +#define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C +#define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D +#define GL_FLOAT_RGBA_MODE_NV 0x888E + +#define GLEW_NV_float_buffer GLEW_GET_VAR(__GLEW_NV_float_buffer) + +#endif /* GL_NV_float_buffer */ + +/* --------------------------- GL_NV_fog_distance -------------------------- */ + +#ifndef GL_NV_fog_distance +#define GL_NV_fog_distance 1 + +#define GL_FOG_DISTANCE_MODE_NV 0x855A +#define GL_EYE_RADIAL_NV 0x855B +#define GL_EYE_PLANE_ABSOLUTE_NV 0x855C + +#define GLEW_NV_fog_distance GLEW_GET_VAR(__GLEW_NV_fog_distance) + +#endif /* GL_NV_fog_distance */ + +/* ------------------------- GL_NV_fragment_program ------------------------ */ + +#ifndef GL_NV_fragment_program +#define GL_NV_fragment_program 1 + +#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 +#define GL_FRAGMENT_PROGRAM_NV 0x8870 +#define GL_MAX_TEXTURE_COORDS_NV 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 +#define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 +#define GL_PROGRAM_ERROR_STRING_NV 0x8874 + +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble *params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLdouble v[]); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLfloat v[]); + +#define glGetProgramNamedParameterdvNV GLEW_GET_FUN(__glewGetProgramNamedParameterdvNV) +#define glGetProgramNamedParameterfvNV GLEW_GET_FUN(__glewGetProgramNamedParameterfvNV) +#define glProgramNamedParameter4dNV GLEW_GET_FUN(__glewProgramNamedParameter4dNV) +#define glProgramNamedParameter4dvNV GLEW_GET_FUN(__glewProgramNamedParameter4dvNV) +#define glProgramNamedParameter4fNV GLEW_GET_FUN(__glewProgramNamedParameter4fNV) +#define glProgramNamedParameter4fvNV GLEW_GET_FUN(__glewProgramNamedParameter4fvNV) + +#define GLEW_NV_fragment_program GLEW_GET_VAR(__GLEW_NV_fragment_program) + +#endif /* GL_NV_fragment_program */ + +/* ------------------------ GL_NV_fragment_program2 ------------------------ */ + +#ifndef GL_NV_fragment_program2 +#define GL_NV_fragment_program2 1 + +#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 +#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 +#define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6 +#define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7 +#define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8 + +#define GLEW_NV_fragment_program2 GLEW_GET_VAR(__GLEW_NV_fragment_program2) + +#endif /* GL_NV_fragment_program2 */ + +/* ------------------------ GL_NV_fragment_program4 ------------------------ */ + +#ifndef GL_NV_fragment_program4 +#define GL_NV_fragment_program4 1 + +#define GLEW_NV_fragment_program4 GLEW_GET_VAR(__GLEW_NV_fragment_program4) + +#endif /* GL_NV_fragment_program4 */ + +/* --------------------- GL_NV_fragment_program_option --------------------- */ + +#ifndef GL_NV_fragment_program_option +#define GL_NV_fragment_program_option 1 + +#define GLEW_NV_fragment_program_option GLEW_GET_VAR(__GLEW_NV_fragment_program_option) + +#endif /* GL_NV_fragment_program_option */ + +/* ----------------- GL_NV_framebuffer_multisample_coverage ---------------- */ + +#ifndef GL_NV_framebuffer_multisample_coverage +#define GL_NV_framebuffer_multisample_coverage 1 + +#define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8CAB +#define GL_RENDERBUFFER_COLOR_SAMPLES_NV 0x8E10 +#define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV 0x8E11 +#define GL_MULTISAMPLE_COVERAGE_MODES_NV 0x8E12 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glRenderbufferStorageMultisampleCoverageNV GLEW_GET_FUN(__glewRenderbufferStorageMultisampleCoverageNV) + +#define GLEW_NV_framebuffer_multisample_coverage GLEW_GET_VAR(__GLEW_NV_framebuffer_multisample_coverage) + +#endif /* GL_NV_framebuffer_multisample_coverage */ + +/* ------------------------ GL_NV_geometry_program4 ------------------------ */ + +#ifndef GL_NV_geometry_program4 +#define GL_NV_geometry_program4 1 + +#define GL_GEOMETRY_PROGRAM_NV 0x8C26 +#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27 +#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28 + +typedef void (GLAPIENTRY * PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GLint limit); + +#define glProgramVertexLimitNV GLEW_GET_FUN(__glewProgramVertexLimitNV) + +#define GLEW_NV_geometry_program4 GLEW_GET_VAR(__GLEW_NV_geometry_program4) + +#endif /* GL_NV_geometry_program4 */ + +/* ------------------------- GL_NV_geometry_shader4 ------------------------ */ + +#ifndef GL_NV_geometry_shader4 +#define GL_NV_geometry_shader4 1 + +#define GLEW_NV_geometry_shader4 GLEW_GET_VAR(__GLEW_NV_geometry_shader4) + +#endif /* GL_NV_geometry_shader4 */ + +/* --------------------------- GL_NV_gpu_program4 -------------------------- */ + +#ifndef GL_NV_gpu_program4 +#define GL_NV_gpu_program4 1 + +#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET_NV 0x8905 +#define GL_PROGRAM_ATTRIB_COMPONENTS_NV 0x8906 +#define GL_PROGRAM_RESULT_COMPONENTS_NV 0x8907 +#define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV 0x8908 +#define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV 0x8909 +#define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV 0x8DA5 +#define GL_MAX_PROGRAM_GENERIC_RESULTS_NV 0x8DA6 + +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); + +#define glProgramEnvParameterI4iNV GLEW_GET_FUN(__glewProgramEnvParameterI4iNV) +#define glProgramEnvParameterI4ivNV GLEW_GET_FUN(__glewProgramEnvParameterI4ivNV) +#define glProgramEnvParameterI4uiNV GLEW_GET_FUN(__glewProgramEnvParameterI4uiNV) +#define glProgramEnvParameterI4uivNV GLEW_GET_FUN(__glewProgramEnvParameterI4uivNV) +#define glProgramEnvParametersI4ivNV GLEW_GET_FUN(__glewProgramEnvParametersI4ivNV) +#define glProgramEnvParametersI4uivNV GLEW_GET_FUN(__glewProgramEnvParametersI4uivNV) +#define glProgramLocalParameterI4iNV GLEW_GET_FUN(__glewProgramLocalParameterI4iNV) +#define glProgramLocalParameterI4ivNV GLEW_GET_FUN(__glewProgramLocalParameterI4ivNV) +#define glProgramLocalParameterI4uiNV GLEW_GET_FUN(__glewProgramLocalParameterI4uiNV) +#define glProgramLocalParameterI4uivNV GLEW_GET_FUN(__glewProgramLocalParameterI4uivNV) +#define glProgramLocalParametersI4ivNV GLEW_GET_FUN(__glewProgramLocalParametersI4ivNV) +#define glProgramLocalParametersI4uivNV GLEW_GET_FUN(__glewProgramLocalParametersI4uivNV) + +#define GLEW_NV_gpu_program4 GLEW_GET_VAR(__GLEW_NV_gpu_program4) + +#endif /* GL_NV_gpu_program4 */ + +/* --------------------------- GL_NV_gpu_program5 -------------------------- */ + +#ifndef GL_NV_gpu_program5 +#define GL_NV_gpu_program5 1 + +#define GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV 0x8E5A +#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5B +#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5C +#define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV 0x8E5D +#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5E +#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5F + +#define GLEW_NV_gpu_program5 GLEW_GET_VAR(__GLEW_NV_gpu_program5) + +#endif /* GL_NV_gpu_program5 */ + +/* ------------------------- GL_NV_gpu_program_fp64 ------------------------ */ + +#ifndef GL_NV_gpu_program_fp64 +#define GL_NV_gpu_program_fp64 1 + +#define GLEW_NV_gpu_program_fp64 GLEW_GET_VAR(__GLEW_NV_gpu_program_fp64) + +#endif /* GL_NV_gpu_program_fp64 */ + +/* --------------------------- GL_NV_gpu_shader5 --------------------------- */ + +#ifndef GL_NV_gpu_shader5 +#define GL_NV_gpu_shader5 1 + +#define GL_INT64_NV 0x140E +#define GL_UNSIGNED_INT64_NV 0x140F +#define GL_INT8_NV 0x8FE0 +#define GL_INT8_VEC2_NV 0x8FE1 +#define GL_INT8_VEC3_NV 0x8FE2 +#define GL_INT8_VEC4_NV 0x8FE3 +#define GL_INT16_NV 0x8FE4 +#define GL_INT16_VEC2_NV 0x8FE5 +#define GL_INT16_VEC3_NV 0x8FE6 +#define GL_INT16_VEC4_NV 0x8FE7 +#define GL_INT64_VEC2_NV 0x8FE9 +#define GL_INT64_VEC3_NV 0x8FEA +#define GL_INT64_VEC4_NV 0x8FEB +#define GL_UNSIGNED_INT8_NV 0x8FEC +#define GL_UNSIGNED_INT8_VEC2_NV 0x8FED +#define GL_UNSIGNED_INT8_VEC3_NV 0x8FEE +#define GL_UNSIGNED_INT8_VEC4_NV 0x8FEF +#define GL_UNSIGNED_INT16_NV 0x8FF0 +#define GL_UNSIGNED_INT16_VEC2_NV 0x8FF1 +#define GL_UNSIGNED_INT16_VEC3_NV 0x8FF2 +#define GL_UNSIGNED_INT16_VEC4_NV 0x8FF3 +#define GL_UNSIGNED_INT64_VEC2_NV 0x8FF5 +#define GL_UNSIGNED_INT64_VEC3_NV 0x8FF6 +#define GL_UNSIGNED_INT64_VEC4_NV 0x8FF7 +#define GL_FLOAT16_NV 0x8FF8 +#define GL_FLOAT16_VEC2_NV 0x8FF9 +#define GL_FLOAT16_VEC3_NV 0x8FFA +#define GL_FLOAT16_VEC4_NV 0x8FFB + +typedef void (GLAPIENTRY * PFNGLGETUNIFORMI64VNVPROC) (GLuint program, GLint location, GLint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLuint64EXT* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64NVPROC) (GLuint program, GLint location, GLint64EXT x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1I64NVPROC) (GLint location, GLint64EXT x); +typedef void (GLAPIENTRY * PFNGLUNIFORM1I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64NVPROC) (GLint location, GLuint64EXT x); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y); +typedef void (GLAPIENTRY * PFNGLUNIFORM2I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); +typedef void (GLAPIENTRY * PFNGLUNIFORM3I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +typedef void (GLAPIENTRY * PFNGLUNIFORM4I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); + +#define glGetUniformi64vNV GLEW_GET_FUN(__glewGetUniformi64vNV) +#define glGetUniformui64vNV GLEW_GET_FUN(__glewGetUniformui64vNV) +#define glProgramUniform1i64NV GLEW_GET_FUN(__glewProgramUniform1i64NV) +#define glProgramUniform1i64vNV GLEW_GET_FUN(__glewProgramUniform1i64vNV) +#define glProgramUniform1ui64NV GLEW_GET_FUN(__glewProgramUniform1ui64NV) +#define glProgramUniform1ui64vNV GLEW_GET_FUN(__glewProgramUniform1ui64vNV) +#define glProgramUniform2i64NV GLEW_GET_FUN(__glewProgramUniform2i64NV) +#define glProgramUniform2i64vNV GLEW_GET_FUN(__glewProgramUniform2i64vNV) +#define glProgramUniform2ui64NV GLEW_GET_FUN(__glewProgramUniform2ui64NV) +#define glProgramUniform2ui64vNV GLEW_GET_FUN(__glewProgramUniform2ui64vNV) +#define glProgramUniform3i64NV GLEW_GET_FUN(__glewProgramUniform3i64NV) +#define glProgramUniform3i64vNV GLEW_GET_FUN(__glewProgramUniform3i64vNV) +#define glProgramUniform3ui64NV GLEW_GET_FUN(__glewProgramUniform3ui64NV) +#define glProgramUniform3ui64vNV GLEW_GET_FUN(__glewProgramUniform3ui64vNV) +#define glProgramUniform4i64NV GLEW_GET_FUN(__glewProgramUniform4i64NV) +#define glProgramUniform4i64vNV GLEW_GET_FUN(__glewProgramUniform4i64vNV) +#define glProgramUniform4ui64NV GLEW_GET_FUN(__glewProgramUniform4ui64NV) +#define glProgramUniform4ui64vNV GLEW_GET_FUN(__glewProgramUniform4ui64vNV) +#define glUniform1i64NV GLEW_GET_FUN(__glewUniform1i64NV) +#define glUniform1i64vNV GLEW_GET_FUN(__glewUniform1i64vNV) +#define glUniform1ui64NV GLEW_GET_FUN(__glewUniform1ui64NV) +#define glUniform1ui64vNV GLEW_GET_FUN(__glewUniform1ui64vNV) +#define glUniform2i64NV GLEW_GET_FUN(__glewUniform2i64NV) +#define glUniform2i64vNV GLEW_GET_FUN(__glewUniform2i64vNV) +#define glUniform2ui64NV GLEW_GET_FUN(__glewUniform2ui64NV) +#define glUniform2ui64vNV GLEW_GET_FUN(__glewUniform2ui64vNV) +#define glUniform3i64NV GLEW_GET_FUN(__glewUniform3i64NV) +#define glUniform3i64vNV GLEW_GET_FUN(__glewUniform3i64vNV) +#define glUniform3ui64NV GLEW_GET_FUN(__glewUniform3ui64NV) +#define glUniform3ui64vNV GLEW_GET_FUN(__glewUniform3ui64vNV) +#define glUniform4i64NV GLEW_GET_FUN(__glewUniform4i64NV) +#define glUniform4i64vNV GLEW_GET_FUN(__glewUniform4i64vNV) +#define glUniform4ui64NV GLEW_GET_FUN(__glewUniform4ui64NV) +#define glUniform4ui64vNV GLEW_GET_FUN(__glewUniform4ui64vNV) + +#define GLEW_NV_gpu_shader5 GLEW_GET_VAR(__GLEW_NV_gpu_shader5) + +#endif /* GL_NV_gpu_shader5 */ + +/* ---------------------------- GL_NV_half_float --------------------------- */ + +#ifndef GL_NV_half_float +#define GL_NV_half_float 1 + +#define GL_HALF_FLOAT_NV 0x140B + +typedef unsigned short GLhalf; + +typedef void (GLAPIENTRY * PFNGLCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); +typedef void (GLAPIENTRY * PFNGLCOLOR3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLCOLOR4HNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha); +typedef void (GLAPIENTRY * PFNGLCOLOR4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHNVPROC) (GLhalf fog); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHVNVPROC) (const GLhalf* fog); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalf s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalf s, GLhalf t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLNORMAL3HNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz); +typedef void (GLAPIENTRY * PFNGLNORMAL3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HNVPROC) (GLhalf s); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HNVPROC) (GLhalf s, GLhalf t); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HNVPROC) (GLhalf s, GLhalf t, GLhalf r); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX2HNVPROC) (GLhalf x, GLhalf y); +typedef void (GLAPIENTRY * PFNGLVERTEX2HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX3HNVPROC) (GLhalf x, GLhalf y, GLhalf z); +typedef void (GLAPIENTRY * PFNGLVERTEX3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX4HNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w); +typedef void (GLAPIENTRY * PFNGLVERTEX4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalf x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalf x, GLhalf y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHNVPROC) (GLhalf weight); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalf* weight); + +#define glColor3hNV GLEW_GET_FUN(__glewColor3hNV) +#define glColor3hvNV GLEW_GET_FUN(__glewColor3hvNV) +#define glColor4hNV GLEW_GET_FUN(__glewColor4hNV) +#define glColor4hvNV GLEW_GET_FUN(__glewColor4hvNV) +#define glFogCoordhNV GLEW_GET_FUN(__glewFogCoordhNV) +#define glFogCoordhvNV GLEW_GET_FUN(__glewFogCoordhvNV) +#define glMultiTexCoord1hNV GLEW_GET_FUN(__glewMultiTexCoord1hNV) +#define glMultiTexCoord1hvNV GLEW_GET_FUN(__glewMultiTexCoord1hvNV) +#define glMultiTexCoord2hNV GLEW_GET_FUN(__glewMultiTexCoord2hNV) +#define glMultiTexCoord2hvNV GLEW_GET_FUN(__glewMultiTexCoord2hvNV) +#define glMultiTexCoord3hNV GLEW_GET_FUN(__glewMultiTexCoord3hNV) +#define glMultiTexCoord3hvNV GLEW_GET_FUN(__glewMultiTexCoord3hvNV) +#define glMultiTexCoord4hNV GLEW_GET_FUN(__glewMultiTexCoord4hNV) +#define glMultiTexCoord4hvNV GLEW_GET_FUN(__glewMultiTexCoord4hvNV) +#define glNormal3hNV GLEW_GET_FUN(__glewNormal3hNV) +#define glNormal3hvNV GLEW_GET_FUN(__glewNormal3hvNV) +#define glSecondaryColor3hNV GLEW_GET_FUN(__glewSecondaryColor3hNV) +#define glSecondaryColor3hvNV GLEW_GET_FUN(__glewSecondaryColor3hvNV) +#define glTexCoord1hNV GLEW_GET_FUN(__glewTexCoord1hNV) +#define glTexCoord1hvNV GLEW_GET_FUN(__glewTexCoord1hvNV) +#define glTexCoord2hNV GLEW_GET_FUN(__glewTexCoord2hNV) +#define glTexCoord2hvNV GLEW_GET_FUN(__glewTexCoord2hvNV) +#define glTexCoord3hNV GLEW_GET_FUN(__glewTexCoord3hNV) +#define glTexCoord3hvNV GLEW_GET_FUN(__glewTexCoord3hvNV) +#define glTexCoord4hNV GLEW_GET_FUN(__glewTexCoord4hNV) +#define glTexCoord4hvNV GLEW_GET_FUN(__glewTexCoord4hvNV) +#define glVertex2hNV GLEW_GET_FUN(__glewVertex2hNV) +#define glVertex2hvNV GLEW_GET_FUN(__glewVertex2hvNV) +#define glVertex3hNV GLEW_GET_FUN(__glewVertex3hNV) +#define glVertex3hvNV GLEW_GET_FUN(__glewVertex3hvNV) +#define glVertex4hNV GLEW_GET_FUN(__glewVertex4hNV) +#define glVertex4hvNV GLEW_GET_FUN(__glewVertex4hvNV) +#define glVertexAttrib1hNV GLEW_GET_FUN(__glewVertexAttrib1hNV) +#define glVertexAttrib1hvNV GLEW_GET_FUN(__glewVertexAttrib1hvNV) +#define glVertexAttrib2hNV GLEW_GET_FUN(__glewVertexAttrib2hNV) +#define glVertexAttrib2hvNV GLEW_GET_FUN(__glewVertexAttrib2hvNV) +#define glVertexAttrib3hNV GLEW_GET_FUN(__glewVertexAttrib3hNV) +#define glVertexAttrib3hvNV GLEW_GET_FUN(__glewVertexAttrib3hvNV) +#define glVertexAttrib4hNV GLEW_GET_FUN(__glewVertexAttrib4hNV) +#define glVertexAttrib4hvNV GLEW_GET_FUN(__glewVertexAttrib4hvNV) +#define glVertexAttribs1hvNV GLEW_GET_FUN(__glewVertexAttribs1hvNV) +#define glVertexAttribs2hvNV GLEW_GET_FUN(__glewVertexAttribs2hvNV) +#define glVertexAttribs3hvNV GLEW_GET_FUN(__glewVertexAttribs3hvNV) +#define glVertexAttribs4hvNV GLEW_GET_FUN(__glewVertexAttribs4hvNV) +#define glVertexWeighthNV GLEW_GET_FUN(__glewVertexWeighthNV) +#define glVertexWeighthvNV GLEW_GET_FUN(__glewVertexWeighthvNV) + +#define GLEW_NV_half_float GLEW_GET_VAR(__GLEW_NV_half_float) + +#endif /* GL_NV_half_float */ + +/* ------------------------ GL_NV_light_max_exponent ----------------------- */ + +#ifndef GL_NV_light_max_exponent +#define GL_NV_light_max_exponent 1 + +#define GL_MAX_SHININESS_NV 0x8504 +#define GL_MAX_SPOT_EXPONENT_NV 0x8505 + +#define GLEW_NV_light_max_exponent GLEW_GET_VAR(__GLEW_NV_light_max_exponent) + +#endif /* GL_NV_light_max_exponent */ + +/* ----------------------- GL_NV_multisample_coverage ---------------------- */ + +#ifndef GL_NV_multisample_coverage +#define GL_NV_multisample_coverage 1 + +#define GL_COVERAGE_SAMPLES_NV 0x80A9 +#define GL_COLOR_SAMPLES_NV 0x8E20 + +#define GLEW_NV_multisample_coverage GLEW_GET_VAR(__GLEW_NV_multisample_coverage) + +#endif /* GL_NV_multisample_coverage */ + +/* --------------------- GL_NV_multisample_filter_hint --------------------- */ + +#ifndef GL_NV_multisample_filter_hint +#define GL_NV_multisample_filter_hint 1 + +#define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534 + +#define GLEW_NV_multisample_filter_hint GLEW_GET_VAR(__GLEW_NV_multisample_filter_hint) + +#endif /* GL_NV_multisample_filter_hint */ + +/* ------------------------- GL_NV_occlusion_query ------------------------- */ + +#ifndef GL_NV_occlusion_query +#define GL_NV_occlusion_query 1 + +#define GL_PIXEL_COUNTER_BITS_NV 0x8864 +#define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 +#define GL_PIXEL_COUNT_NV 0x8866 +#define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 + +typedef void (GLAPIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (void); +typedef void (GLAPIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); + +#define glBeginOcclusionQueryNV GLEW_GET_FUN(__glewBeginOcclusionQueryNV) +#define glDeleteOcclusionQueriesNV GLEW_GET_FUN(__glewDeleteOcclusionQueriesNV) +#define glEndOcclusionQueryNV GLEW_GET_FUN(__glewEndOcclusionQueryNV) +#define glGenOcclusionQueriesNV GLEW_GET_FUN(__glewGenOcclusionQueriesNV) +#define glGetOcclusionQueryivNV GLEW_GET_FUN(__glewGetOcclusionQueryivNV) +#define glGetOcclusionQueryuivNV GLEW_GET_FUN(__glewGetOcclusionQueryuivNV) +#define glIsOcclusionQueryNV GLEW_GET_FUN(__glewIsOcclusionQueryNV) + +#define GLEW_NV_occlusion_query GLEW_GET_VAR(__GLEW_NV_occlusion_query) + +#endif /* GL_NV_occlusion_query */ + +/* ----------------------- GL_NV_packed_depth_stencil ---------------------- */ + +#ifndef GL_NV_packed_depth_stencil +#define GL_NV_packed_depth_stencil 1 + +#define GL_DEPTH_STENCIL_NV 0x84F9 +#define GL_UNSIGNED_INT_24_8_NV 0x84FA + +#define GLEW_NV_packed_depth_stencil GLEW_GET_VAR(__GLEW_NV_packed_depth_stencil) + +#endif /* GL_NV_packed_depth_stencil */ + +/* --------------------- GL_NV_parameter_buffer_object --------------------- */ + +#ifndef GL_NV_parameter_buffer_object +#define GL_NV_parameter_buffer_object 1 + +#define GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV 0x8DA0 +#define GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV 0x8DA1 +#define GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV 0x8DA2 +#define GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV 0x8DA3 +#define GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV 0x8DA4 + +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params); + +#define glProgramBufferParametersIivNV GLEW_GET_FUN(__glewProgramBufferParametersIivNV) +#define glProgramBufferParametersIuivNV GLEW_GET_FUN(__glewProgramBufferParametersIuivNV) +#define glProgramBufferParametersfvNV GLEW_GET_FUN(__glewProgramBufferParametersfvNV) + +#define GLEW_NV_parameter_buffer_object GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object) + +#endif /* GL_NV_parameter_buffer_object */ + +/* --------------------- GL_NV_parameter_buffer_object2 -------------------- */ + +#ifndef GL_NV_parameter_buffer_object2 +#define GL_NV_parameter_buffer_object2 1 + +#define GLEW_NV_parameter_buffer_object2 GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object2) + +#endif /* GL_NV_parameter_buffer_object2 */ + +/* -------------------------- GL_NV_path_rendering ------------------------- */ + +#ifndef GL_NV_path_rendering +#define GL_NV_path_rendering 1 + +#define GL_CLOSE_PATH_NV 0x00 +#define GL_BOLD_BIT_NV 0x01 +#define GL_GLYPH_WIDTH_BIT_NV 0x01 +#define GL_MOVE_TO_NV 0x02 +#define GL_GLYPH_HEIGHT_BIT_NV 0x02 +#define GL_ITALIC_BIT_NV 0x02 +#define GL_RELATIVE_MOVE_TO_NV 0x03 +#define GL_LINE_TO_NV 0x04 +#define GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV 0x04 +#define GL_RELATIVE_LINE_TO_NV 0x05 +#define GL_HORIZONTAL_LINE_TO_NV 0x06 +#define GL_RELATIVE_HORIZONTAL_LINE_TO_NV 0x07 +#define GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV 0x08 +#define GL_VERTICAL_LINE_TO_NV 0x08 +#define GL_RELATIVE_VERTICAL_LINE_TO_NV 0x09 +#define GL_QUADRATIC_CURVE_TO_NV 0x0A +#define GL_RELATIVE_QUADRATIC_CURVE_TO_NV 0x0B +#define GL_CUBIC_CURVE_TO_NV 0x0C +#define GL_RELATIVE_CUBIC_CURVE_TO_NV 0x0D +#define GL_SMOOTH_QUADRATIC_CURVE_TO_NV 0x0E +#define GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV 0x0F +#define GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV 0x10 +#define GL_SMOOTH_CUBIC_CURVE_TO_NV 0x10 +#define GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV 0x11 +#define GL_SMALL_CCW_ARC_TO_NV 0x12 +#define GL_RELATIVE_SMALL_CCW_ARC_TO_NV 0x13 +#define GL_SMALL_CW_ARC_TO_NV 0x14 +#define GL_RELATIVE_SMALL_CW_ARC_TO_NV 0x15 +#define GL_LARGE_CCW_ARC_TO_NV 0x16 +#define GL_RELATIVE_LARGE_CCW_ARC_TO_NV 0x17 +#define GL_LARGE_CW_ARC_TO_NV 0x18 +#define GL_RELATIVE_LARGE_CW_ARC_TO_NV 0x19 +#define GL_GLYPH_VERTICAL_BEARING_X_BIT_NV 0x20 +#define GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV 0x40 +#define GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV 0x80 +#define GL_CIRCULAR_CCW_ARC_TO_NV 0xF8 +#define GL_CIRCULAR_CW_ARC_TO_NV 0xFA +#define GL_CIRCULAR_TANGENT_ARC_TO_NV 0xFC +#define GL_ARC_TO_NV 0xFE +#define GL_RELATIVE_ARC_TO_NV 0xFF +#define GL_GLYPH_HAS_KERNING_NV 0x100 +#define GL_PRIMARY_COLOR_NV 0x852C +#define GL_SECONDARY_COLOR_NV 0x852D +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PATH_FORMAT_SVG_NV 0x9070 +#define GL_PATH_FORMAT_PS_NV 0x9071 +#define GL_STANDARD_FONT_NAME_NV 0x9072 +#define GL_SYSTEM_FONT_NAME_NV 0x9073 +#define GL_FILE_NAME_NV 0x9074 +#define GL_PATH_STROKE_WIDTH_NV 0x9075 +#define GL_PATH_END_CAPS_NV 0x9076 +#define GL_PATH_INITIAL_END_CAP_NV 0x9077 +#define GL_PATH_TERMINAL_END_CAP_NV 0x9078 +#define GL_PATH_JOIN_STYLE_NV 0x9079 +#define GL_PATH_MITER_LIMIT_NV 0x907A +#define GL_PATH_DASH_CAPS_NV 0x907B +#define GL_PATH_INITIAL_DASH_CAP_NV 0x907C +#define GL_PATH_TERMINAL_DASH_CAP_NV 0x907D +#define GL_PATH_DASH_OFFSET_NV 0x907E +#define GL_PATH_CLIENT_LENGTH_NV 0x907F +#define GL_PATH_FILL_MODE_NV 0x9080 +#define GL_PATH_FILL_MASK_NV 0x9081 +#define GL_PATH_FILL_COVER_MODE_NV 0x9082 +#define GL_PATH_STROKE_COVER_MODE_NV 0x9083 +#define GL_PATH_STROKE_MASK_NV 0x9084 +#define GL_COUNT_UP_NV 0x9088 +#define GL_COUNT_DOWN_NV 0x9089 +#define GL_PATH_OBJECT_BOUNDING_BOX_NV 0x908A +#define GL_CONVEX_HULL_NV 0x908B +#define GL_BOUNDING_BOX_NV 0x908D +#define GL_TRANSLATE_X_NV 0x908E +#define GL_TRANSLATE_Y_NV 0x908F +#define GL_TRANSLATE_2D_NV 0x9090 +#define GL_TRANSLATE_3D_NV 0x9091 +#define GL_AFFINE_2D_NV 0x9092 +#define GL_AFFINE_3D_NV 0x9094 +#define GL_TRANSPOSE_AFFINE_2D_NV 0x9096 +#define GL_TRANSPOSE_AFFINE_3D_NV 0x9098 +#define GL_UTF8_NV 0x909A +#define GL_UTF16_NV 0x909B +#define GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV 0x909C +#define GL_PATH_COMMAND_COUNT_NV 0x909D +#define GL_PATH_COORD_COUNT_NV 0x909E +#define GL_PATH_DASH_ARRAY_COUNT_NV 0x909F +#define GL_PATH_COMPUTED_LENGTH_NV 0x90A0 +#define GL_PATH_FILL_BOUNDING_BOX_NV 0x90A1 +#define GL_PATH_STROKE_BOUNDING_BOX_NV 0x90A2 +#define GL_SQUARE_NV 0x90A3 +#define GL_ROUND_NV 0x90A4 +#define GL_TRIANGULAR_NV 0x90A5 +#define GL_BEVEL_NV 0x90A6 +#define GL_MITER_REVERT_NV 0x90A7 +#define GL_MITER_TRUNCATE_NV 0x90A8 +#define GL_SKIP_MISSING_GLYPH_NV 0x90A9 +#define GL_USE_MISSING_GLYPH_NV 0x90AA +#define GL_PATH_ERROR_POSITION_NV 0x90AB +#define GL_PATH_FOG_GEN_MODE_NV 0x90AC +#define GL_ACCUM_ADJACENT_PAIRS_NV 0x90AD +#define GL_ADJACENT_PAIRS_NV 0x90AE +#define GL_FIRST_TO_REST_NV 0x90AF +#define GL_PATH_GEN_MODE_NV 0x90B0 +#define GL_PATH_GEN_COEFF_NV 0x90B1 +#define GL_PATH_GEN_COLOR_FORMAT_NV 0x90B2 +#define GL_PATH_GEN_COMPONENTS_NV 0x90B3 +#define GL_PATH_DASH_OFFSET_RESET_NV 0x90B4 +#define GL_MOVE_TO_RESETS_NV 0x90B5 +#define GL_MOVE_TO_CONTINUES_NV 0x90B6 +#define GL_PATH_STENCIL_FUNC_NV 0x90B7 +#define GL_PATH_STENCIL_REF_NV 0x90B8 +#define GL_PATH_STENCIL_VALUE_MASK_NV 0x90B9 +#define GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV 0x90BD +#define GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV 0x90BE +#define GL_PATH_COVER_DEPTH_FUNC_NV 0x90BF +#define GL_FONT_X_MIN_BOUNDS_NV 0x00010000 +#define GL_FONT_Y_MIN_BOUNDS_NV 0x00020000 +#define GL_FONT_X_MAX_BOUNDS_NV 0x00040000 +#define GL_FONT_Y_MAX_BOUNDS_NV 0x00080000 +#define GL_FONT_UNITS_PER_EM_NV 0x00100000 +#define GL_FONT_ASCENDER_NV 0x00200000 +#define GL_FONT_DESCENDER_NV 0x00400000 +#define GL_FONT_HEIGHT_NV 0x00800000 +#define GL_FONT_MAX_ADVANCE_WIDTH_NV 0x01000000 +#define GL_FONT_MAX_ADVANCE_HEIGHT_NV 0x02000000 +#define GL_FONT_UNDERLINE_POSITION_NV 0x04000000 +#define GL_FONT_UNDERLINE_THICKNESS_NV 0x08000000 +#define GL_FONT_HAS_KERNING_NV 0x10000000 + +typedef void (GLAPIENTRY * PFNGLCOPYPATHNVPROC) (GLuint resultPath, GLuint srcPath); +typedef void (GLAPIENTRY * PFNGLCOVERFILLPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); +typedef void (GLAPIENTRY * PFNGLCOVERFILLPATHNVPROC) (GLuint path, GLenum coverMode); +typedef void (GLAPIENTRY * PFNGLCOVERSTROKEPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); +typedef void (GLAPIENTRY * PFNGLCOVERSTROKEPATHNVPROC) (GLuint name, GLenum coverMode); +typedef void (GLAPIENTRY * PFNGLDELETEPATHSNVPROC) (GLuint path, GLsizei range); +typedef GLuint (GLAPIENTRY * PFNGLGENPATHSNVPROC) (GLsizei range); +typedef void (GLAPIENTRY * PFNGLGETPATHCOLORGENFVNVPROC) (GLenum color, GLenum pname, GLfloat* value); +typedef void (GLAPIENTRY * PFNGLGETPATHCOLORGENIVNVPROC) (GLenum color, GLenum pname, GLint* value); +typedef void (GLAPIENTRY * PFNGLGETPATHCOMMANDSNVPROC) (GLuint name, GLubyte* commands); +typedef void (GLAPIENTRY * PFNGLGETPATHCOORDSNVPROC) (GLuint name, GLfloat* coords); +typedef void (GLAPIENTRY * PFNGLGETPATHDASHARRAYNVPROC) (GLuint name, GLfloat* dashArray); +typedef GLfloat (GLAPIENTRY * PFNGLGETPATHLENGTHNVPROC) (GLuint path, GLsizei startSegment, GLsizei numSegments); +typedef void (GLAPIENTRY * PFNGLGETPATHMETRICRANGENVPROC) (GLbitfield metricQueryMask, GLuint fistPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics); +typedef void (GLAPIENTRY * PFNGLGETPATHMETRICSNVPROC) (GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLsizei stride, GLfloat *metrics); +typedef void (GLAPIENTRY * PFNGLGETPATHPARAMETERFVNVPROC) (GLuint name, GLenum param, GLfloat* value); +typedef void (GLAPIENTRY * PFNGLGETPATHPARAMETERIVNVPROC) (GLuint name, GLenum param, GLint* value); +typedef void (GLAPIENTRY * PFNGLGETPATHSPACINGNVPROC) (GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing); +typedef void (GLAPIENTRY * PFNGLGETPATHTEXGENFVNVPROC) (GLenum texCoordSet, GLenum pname, GLfloat* value); +typedef void (GLAPIENTRY * PFNGLGETPATHTEXGENIVNVPROC) (GLenum texCoordSet, GLenum pname, GLint* value); +typedef void (GLAPIENTRY * PFNGLINTERPOLATEPATHSNVPROC) (GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight); +typedef GLboolean (GLAPIENTRY * PFNGLISPATHNVPROC) (GLuint path); +typedef GLboolean (GLAPIENTRY * PFNGLISPOINTINFILLPATHNVPROC) (GLuint path, GLuint mask, GLfloat x, GLfloat y); +typedef GLboolean (GLAPIENTRY * PFNGLISPOINTINSTROKEPATHNVPROC) (GLuint path, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLPATHCOLORGENNVPROC) (GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs); +typedef void (GLAPIENTRY * PFNGLPATHCOMMANDSNVPROC) (GLuint path, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const GLvoid*coords); +typedef void (GLAPIENTRY * PFNGLPATHCOORDSNVPROC) (GLuint path, GLsizei numCoords, GLenum coordType, const void* coords); +typedef void (GLAPIENTRY * PFNGLPATHCOVERDEPTHFUNCNVPROC) (GLenum zfunc); +typedef void (GLAPIENTRY * PFNGLPATHDASHARRAYNVPROC) (GLuint path, GLsizei dashCount, const GLfloat* dashArray); +typedef void (GLAPIENTRY * PFNGLPATHFOGGENNVPROC) (GLenum genMode); +typedef void (GLAPIENTRY * PFNGLPATHGLYPHRANGENVPROC) (GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +typedef void (GLAPIENTRY * PFNGLPATHGLYPHSNVPROC) (GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const GLvoid*charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +typedef void (GLAPIENTRY * PFNGLPATHPARAMETERFNVPROC) (GLuint path, GLenum pname, GLfloat value); +typedef void (GLAPIENTRY * PFNGLPATHPARAMETERFVNVPROC) (GLuint path, GLenum pname, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPATHPARAMETERINVPROC) (GLuint path, GLenum pname, GLint value); +typedef void (GLAPIENTRY * PFNGLPATHPARAMETERIVNVPROC) (GLuint path, GLenum pname, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPATHSTENCILDEPTHOFFSETNVPROC) (GLfloat factor, GLint units); +typedef void (GLAPIENTRY * PFNGLPATHSTENCILFUNCNVPROC) (GLenum func, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLPATHSTRINGNVPROC) (GLuint path, GLenum format, GLsizei length, const void* pathString); +typedef void (GLAPIENTRY * PFNGLPATHSUBCOMMANDSNVPROC) (GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const GLvoid*coords); +typedef void (GLAPIENTRY * PFNGLPATHSUBCOORDSNVPROC) (GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void* coords); +typedef void (GLAPIENTRY * PFNGLPATHTEXGENNVPROC) (GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs); +typedef GLboolean (GLAPIENTRY * PFNGLPOINTALONGPATHNVPROC) (GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY); +typedef void (GLAPIENTRY * PFNGLSTENCILFILLPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues); +typedef void (GLAPIENTRY * PFNGLSTENCILFILLPATHNVPROC) (GLuint path, GLenum fillMode, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues); +typedef void (GLAPIENTRY * PFNGLSTENCILSTROKEPATHNVPROC) (GLuint path, GLint reference, GLuint mask); +typedef void (GLAPIENTRY * PFNGLTRANSFORMPATHNVPROC) (GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat* transformValues); +typedef void (GLAPIENTRY * PFNGLWEIGHTPATHSNVPROC) (GLuint resultPath, GLsizei numPaths, const GLuint paths[], const GLfloat weights[]); + +#define glCopyPathNV GLEW_GET_FUN(__glewCopyPathNV) +#define glCoverFillPathInstancedNV GLEW_GET_FUN(__glewCoverFillPathInstancedNV) +#define glCoverFillPathNV GLEW_GET_FUN(__glewCoverFillPathNV) +#define glCoverStrokePathInstancedNV GLEW_GET_FUN(__glewCoverStrokePathInstancedNV) +#define glCoverStrokePathNV GLEW_GET_FUN(__glewCoverStrokePathNV) +#define glDeletePathsNV GLEW_GET_FUN(__glewDeletePathsNV) +#define glGenPathsNV GLEW_GET_FUN(__glewGenPathsNV) +#define glGetPathColorGenfvNV GLEW_GET_FUN(__glewGetPathColorGenfvNV) +#define glGetPathColorGenivNV GLEW_GET_FUN(__glewGetPathColorGenivNV) +#define glGetPathCommandsNV GLEW_GET_FUN(__glewGetPathCommandsNV) +#define glGetPathCoordsNV GLEW_GET_FUN(__glewGetPathCoordsNV) +#define glGetPathDashArrayNV GLEW_GET_FUN(__glewGetPathDashArrayNV) +#define glGetPathLengthNV GLEW_GET_FUN(__glewGetPathLengthNV) +#define glGetPathMetricRangeNV GLEW_GET_FUN(__glewGetPathMetricRangeNV) +#define glGetPathMetricsNV GLEW_GET_FUN(__glewGetPathMetricsNV) +#define glGetPathParameterfvNV GLEW_GET_FUN(__glewGetPathParameterfvNV) +#define glGetPathParameterivNV GLEW_GET_FUN(__glewGetPathParameterivNV) +#define glGetPathSpacingNV GLEW_GET_FUN(__glewGetPathSpacingNV) +#define glGetPathTexGenfvNV GLEW_GET_FUN(__glewGetPathTexGenfvNV) +#define glGetPathTexGenivNV GLEW_GET_FUN(__glewGetPathTexGenivNV) +#define glInterpolatePathsNV GLEW_GET_FUN(__glewInterpolatePathsNV) +#define glIsPathNV GLEW_GET_FUN(__glewIsPathNV) +#define glIsPointInFillPathNV GLEW_GET_FUN(__glewIsPointInFillPathNV) +#define glIsPointInStrokePathNV GLEW_GET_FUN(__glewIsPointInStrokePathNV) +#define glPathColorGenNV GLEW_GET_FUN(__glewPathColorGenNV) +#define glPathCommandsNV GLEW_GET_FUN(__glewPathCommandsNV) +#define glPathCoordsNV GLEW_GET_FUN(__glewPathCoordsNV) +#define glPathCoverDepthFuncNV GLEW_GET_FUN(__glewPathCoverDepthFuncNV) +#define glPathDashArrayNV GLEW_GET_FUN(__glewPathDashArrayNV) +#define glPathFogGenNV GLEW_GET_FUN(__glewPathFogGenNV) +#define glPathGlyphRangeNV GLEW_GET_FUN(__glewPathGlyphRangeNV) +#define glPathGlyphsNV GLEW_GET_FUN(__glewPathGlyphsNV) +#define glPathParameterfNV GLEW_GET_FUN(__glewPathParameterfNV) +#define glPathParameterfvNV GLEW_GET_FUN(__glewPathParameterfvNV) +#define glPathParameteriNV GLEW_GET_FUN(__glewPathParameteriNV) +#define glPathParameterivNV GLEW_GET_FUN(__glewPathParameterivNV) +#define glPathStencilDepthOffsetNV GLEW_GET_FUN(__glewPathStencilDepthOffsetNV) +#define glPathStencilFuncNV GLEW_GET_FUN(__glewPathStencilFuncNV) +#define glPathStringNV GLEW_GET_FUN(__glewPathStringNV) +#define glPathSubCommandsNV GLEW_GET_FUN(__glewPathSubCommandsNV) +#define glPathSubCoordsNV GLEW_GET_FUN(__glewPathSubCoordsNV) +#define glPathTexGenNV GLEW_GET_FUN(__glewPathTexGenNV) +#define glPointAlongPathNV GLEW_GET_FUN(__glewPointAlongPathNV) +#define glStencilFillPathInstancedNV GLEW_GET_FUN(__glewStencilFillPathInstancedNV) +#define glStencilFillPathNV GLEW_GET_FUN(__glewStencilFillPathNV) +#define glStencilStrokePathInstancedNV GLEW_GET_FUN(__glewStencilStrokePathInstancedNV) +#define glStencilStrokePathNV GLEW_GET_FUN(__glewStencilStrokePathNV) +#define glTransformPathNV GLEW_GET_FUN(__glewTransformPathNV) +#define glWeightPathsNV GLEW_GET_FUN(__glewWeightPathsNV) + +#define GLEW_NV_path_rendering GLEW_GET_VAR(__GLEW_NV_path_rendering) + +#endif /* GL_NV_path_rendering */ + +/* ------------------------- GL_NV_pixel_data_range ------------------------ */ + +#ifndef GL_NV_pixel_data_range +#define GL_NV_pixel_data_range 1 + +#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878 +#define GL_READ_PIXEL_DATA_RANGE_NV 0x8879 +#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A +#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B +#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C +#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D + +typedef void (GLAPIENTRY * PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, void* pointer); + +#define glFlushPixelDataRangeNV GLEW_GET_FUN(__glewFlushPixelDataRangeNV) +#define glPixelDataRangeNV GLEW_GET_FUN(__glewPixelDataRangeNV) + +#define GLEW_NV_pixel_data_range GLEW_GET_VAR(__GLEW_NV_pixel_data_range) + +#endif /* GL_NV_pixel_data_range */ + +/* --------------------------- GL_NV_point_sprite -------------------------- */ + +#ifndef GL_NV_point_sprite +#define GL_NV_point_sprite 1 + +#define GL_POINT_SPRITE_NV 0x8861 +#define GL_COORD_REPLACE_NV 0x8862 +#define GL_POINT_SPRITE_R_MODE_NV 0x8863 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint* params); + +#define glPointParameteriNV GLEW_GET_FUN(__glewPointParameteriNV) +#define glPointParameterivNV GLEW_GET_FUN(__glewPointParameterivNV) + +#define GLEW_NV_point_sprite GLEW_GET_VAR(__GLEW_NV_point_sprite) + +#endif /* GL_NV_point_sprite */ + +/* -------------------------- GL_NV_present_video -------------------------- */ + +#ifndef GL_NV_present_video +#define GL_NV_present_video 1 + +#define GL_FRAME_NV 0x8E26 +#define GL_FIELDS_NV 0x8E27 +#define GL_CURRENT_TIME_NV 0x8E28 +#define GL_NUM_FILL_STREAMS_NV 0x8E29 +#define GL_PRESENT_TIME_NV 0x8E2A +#define GL_PRESENT_DURATION_NV 0x8E2B + +typedef void (GLAPIENTRY * PFNGLGETVIDEOI64VNVPROC) (GLuint video_slot, GLenum pname, GLint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOIVNVPROC) (GLuint video_slot, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum pname, GLuint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3); +typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1); + +#define glGetVideoi64vNV GLEW_GET_FUN(__glewGetVideoi64vNV) +#define glGetVideoivNV GLEW_GET_FUN(__glewGetVideoivNV) +#define glGetVideoui64vNV GLEW_GET_FUN(__glewGetVideoui64vNV) +#define glGetVideouivNV GLEW_GET_FUN(__glewGetVideouivNV) +#define glPresentFrameDualFillNV GLEW_GET_FUN(__glewPresentFrameDualFillNV) +#define glPresentFrameKeyedNV GLEW_GET_FUN(__glewPresentFrameKeyedNV) + +#define GLEW_NV_present_video GLEW_GET_VAR(__GLEW_NV_present_video) + +#endif /* GL_NV_present_video */ + +/* ------------------------ GL_NV_primitive_restart ------------------------ */ + +#ifndef GL_NV_primitive_restart +#define GL_NV_primitive_restart 1 + +#define GL_PRIMITIVE_RESTART_NV 0x8558 +#define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559 + +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); + +#define glPrimitiveRestartIndexNV GLEW_GET_FUN(__glewPrimitiveRestartIndexNV) +#define glPrimitiveRestartNV GLEW_GET_FUN(__glewPrimitiveRestartNV) + +#define GLEW_NV_primitive_restart GLEW_GET_VAR(__GLEW_NV_primitive_restart) + +#endif /* GL_NV_primitive_restart */ + +/* ------------------------ GL_NV_register_combiners ----------------------- */ + +#ifndef GL_NV_register_combiners +#define GL_NV_register_combiners 1 + +#define GL_REGISTER_COMBINERS_NV 0x8522 +#define GL_VARIABLE_A_NV 0x8523 +#define GL_VARIABLE_B_NV 0x8524 +#define GL_VARIABLE_C_NV 0x8525 +#define GL_VARIABLE_D_NV 0x8526 +#define GL_VARIABLE_E_NV 0x8527 +#define GL_VARIABLE_F_NV 0x8528 +#define GL_VARIABLE_G_NV 0x8529 +#define GL_CONSTANT_COLOR0_NV 0x852A +#define GL_CONSTANT_COLOR1_NV 0x852B +#define GL_PRIMARY_COLOR_NV 0x852C +#define GL_SECONDARY_COLOR_NV 0x852D +#define GL_SPARE0_NV 0x852E +#define GL_SPARE1_NV 0x852F +#define GL_DISCARD_NV 0x8530 +#define GL_E_TIMES_F_NV 0x8531 +#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532 +#define GL_UNSIGNED_IDENTITY_NV 0x8536 +#define GL_UNSIGNED_INVERT_NV 0x8537 +#define GL_EXPAND_NORMAL_NV 0x8538 +#define GL_EXPAND_NEGATE_NV 0x8539 +#define GL_HALF_BIAS_NORMAL_NV 0x853A +#define GL_HALF_BIAS_NEGATE_NV 0x853B +#define GL_SIGNED_IDENTITY_NV 0x853C +#define GL_SIGNED_NEGATE_NV 0x853D +#define GL_SCALE_BY_TWO_NV 0x853E +#define GL_SCALE_BY_FOUR_NV 0x853F +#define GL_SCALE_BY_ONE_HALF_NV 0x8540 +#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 +#define GL_COMBINER_INPUT_NV 0x8542 +#define GL_COMBINER_MAPPING_NV 0x8543 +#define GL_COMBINER_COMPONENT_USAGE_NV 0x8544 +#define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545 +#define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546 +#define GL_COMBINER_MUX_SUM_NV 0x8547 +#define GL_COMBINER_SCALE_NV 0x8548 +#define GL_COMBINER_BIAS_NV 0x8549 +#define GL_COMBINER_AB_OUTPUT_NV 0x854A +#define GL_COMBINER_CD_OUTPUT_NV 0x854B +#define GL_COMBINER_SUM_OUTPUT_NV 0x854C +#define GL_MAX_GENERAL_COMBINERS_NV 0x854D +#define GL_NUM_GENERAL_COMBINERS_NV 0x854E +#define GL_COLOR_SUM_CLAMP_NV 0x854F +#define GL_COMBINER0_NV 0x8550 +#define GL_COMBINER1_NV 0x8551 +#define GL_COMBINER2_NV 0x8552 +#define GL_COMBINER3_NV 0x8553 +#define GL_COMBINER4_NV 0x8554 +#define GL_COMBINER5_NV 0x8555 +#define GL_COMBINER6_NV 0x8556 +#define GL_COMBINER7_NV 0x8557 + +typedef void (GLAPIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint* params); + +#define glCombinerInputNV GLEW_GET_FUN(__glewCombinerInputNV) +#define glCombinerOutputNV GLEW_GET_FUN(__glewCombinerOutputNV) +#define glCombinerParameterfNV GLEW_GET_FUN(__glewCombinerParameterfNV) +#define glCombinerParameterfvNV GLEW_GET_FUN(__glewCombinerParameterfvNV) +#define glCombinerParameteriNV GLEW_GET_FUN(__glewCombinerParameteriNV) +#define glCombinerParameterivNV GLEW_GET_FUN(__glewCombinerParameterivNV) +#define glFinalCombinerInputNV GLEW_GET_FUN(__glewFinalCombinerInputNV) +#define glGetCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetCombinerInputParameterfvNV) +#define glGetCombinerInputParameterivNV GLEW_GET_FUN(__glewGetCombinerInputParameterivNV) +#define glGetCombinerOutputParameterfvNV GLEW_GET_FUN(__glewGetCombinerOutputParameterfvNV) +#define glGetCombinerOutputParameterivNV GLEW_GET_FUN(__glewGetCombinerOutputParameterivNV) +#define glGetFinalCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterfvNV) +#define glGetFinalCombinerInputParameterivNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterivNV) + +#define GLEW_NV_register_combiners GLEW_GET_VAR(__GLEW_NV_register_combiners) + +#endif /* GL_NV_register_combiners */ + +/* ----------------------- GL_NV_register_combiners2 ----------------------- */ + +#ifndef GL_NV_register_combiners2 +#define GL_NV_register_combiners2 1 + +#define GL_PER_STAGE_CONSTANTS_NV 0x8535 + +typedef void (GLAPIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat* params); + +#define glCombinerStageParameterfvNV GLEW_GET_FUN(__glewCombinerStageParameterfvNV) +#define glGetCombinerStageParameterfvNV GLEW_GET_FUN(__glewGetCombinerStageParameterfvNV) + +#define GLEW_NV_register_combiners2 GLEW_GET_VAR(__GLEW_NV_register_combiners2) + +#endif /* GL_NV_register_combiners2 */ + +/* ------------------------ GL_NV_shader_buffer_load ----------------------- */ + +#ifndef GL_NV_shader_buffer_load +#define GL_NV_shader_buffer_load 1 + +#define GL_BUFFER_GPU_ADDRESS_NV 0x8F1D +#define GL_GPU_ADDRESS_NV 0x8F34 +#define GL_MAX_SHADER_BUFFER_ADDRESS_NV 0x8F35 + +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERUI64VNVPROC) (GLenum target, GLenum pname, GLuint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64VNVPROC) (GLenum value, GLuint64EXT* result); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC) (GLuint buffer, GLenum pname, GLuint64EXT* params); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERRESIDENTNVPROC) (GLenum target); +typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDBUFFERRESIDENTNVPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLMAKEBUFFERNONRESIDENTNVPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLMAKEBUFFERRESIDENTNVPROC) (GLenum target, GLenum access); +typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERRESIDENTNVPROC) (GLuint buffer, GLenum access); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64NVPROC) (GLuint program, GLint location, GLuint64EXT value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMUI64NVPROC) (GLint location, GLuint64EXT value); +typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); + +#define glGetBufferParameterui64vNV GLEW_GET_FUN(__glewGetBufferParameterui64vNV) +#define glGetIntegerui64vNV GLEW_GET_FUN(__glewGetIntegerui64vNV) +#define glGetNamedBufferParameterui64vNV GLEW_GET_FUN(__glewGetNamedBufferParameterui64vNV) +#define glIsBufferResidentNV GLEW_GET_FUN(__glewIsBufferResidentNV) +#define glIsNamedBufferResidentNV GLEW_GET_FUN(__glewIsNamedBufferResidentNV) +#define glMakeBufferNonResidentNV GLEW_GET_FUN(__glewMakeBufferNonResidentNV) +#define glMakeBufferResidentNV GLEW_GET_FUN(__glewMakeBufferResidentNV) +#define glMakeNamedBufferNonResidentNV GLEW_GET_FUN(__glewMakeNamedBufferNonResidentNV) +#define glMakeNamedBufferResidentNV GLEW_GET_FUN(__glewMakeNamedBufferResidentNV) +#define glProgramUniformui64NV GLEW_GET_FUN(__glewProgramUniformui64NV) +#define glProgramUniformui64vNV GLEW_GET_FUN(__glewProgramUniformui64vNV) +#define glUniformui64NV GLEW_GET_FUN(__glewUniformui64NV) +#define glUniformui64vNV GLEW_GET_FUN(__glewUniformui64vNV) + +#define GLEW_NV_shader_buffer_load GLEW_GET_VAR(__GLEW_NV_shader_buffer_load) + +#endif /* GL_NV_shader_buffer_load */ + +/* ---------------------- GL_NV_tessellation_program5 ---------------------- */ + +#ifndef GL_NV_tessellation_program5 +#define GL_NV_tessellation_program5 1 + +#define GL_MAX_PROGRAM_PATCH_ATTRIBS_NV 0x86D8 +#define GL_TESS_CONTROL_PROGRAM_NV 0x891E +#define GL_TESS_EVALUATION_PROGRAM_NV 0x891F +#define GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV 0x8C74 +#define GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV 0x8C75 + +#define GLEW_NV_tessellation_program5 GLEW_GET_VAR(__GLEW_NV_tessellation_program5) + +#endif /* GL_NV_tessellation_program5 */ + +/* -------------------------- GL_NV_texgen_emboss -------------------------- */ + +#ifndef GL_NV_texgen_emboss +#define GL_NV_texgen_emboss 1 + +#define GL_EMBOSS_LIGHT_NV 0x855D +#define GL_EMBOSS_CONSTANT_NV 0x855E +#define GL_EMBOSS_MAP_NV 0x855F + +#define GLEW_NV_texgen_emboss GLEW_GET_VAR(__GLEW_NV_texgen_emboss) + +#endif /* GL_NV_texgen_emboss */ + +/* ------------------------ GL_NV_texgen_reflection ------------------------ */ + +#ifndef GL_NV_texgen_reflection +#define GL_NV_texgen_reflection 1 + +#define GL_NORMAL_MAP_NV 0x8511 +#define GL_REFLECTION_MAP_NV 0x8512 + +#define GLEW_NV_texgen_reflection GLEW_GET_VAR(__GLEW_NV_texgen_reflection) + +#endif /* GL_NV_texgen_reflection */ + +/* ------------------------- GL_NV_texture_barrier ------------------------- */ + +#ifndef GL_NV_texture_barrier +#define GL_NV_texture_barrier 1 + +typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERNVPROC) (void); + +#define glTextureBarrierNV GLEW_GET_FUN(__glewTextureBarrierNV) + +#define GLEW_NV_texture_barrier GLEW_GET_VAR(__GLEW_NV_texture_barrier) + +#endif /* GL_NV_texture_barrier */ + +/* --------------------- GL_NV_texture_compression_vtc --------------------- */ + +#ifndef GL_NV_texture_compression_vtc +#define GL_NV_texture_compression_vtc 1 + +#define GLEW_NV_texture_compression_vtc GLEW_GET_VAR(__GLEW_NV_texture_compression_vtc) + +#endif /* GL_NV_texture_compression_vtc */ + +/* ----------------------- GL_NV_texture_env_combine4 ---------------------- */ + +#ifndef GL_NV_texture_env_combine4 +#define GL_NV_texture_env_combine4 1 + +#define GL_COMBINE4_NV 0x8503 +#define GL_SOURCE3_RGB_NV 0x8583 +#define GL_SOURCE3_ALPHA_NV 0x858B +#define GL_OPERAND3_RGB_NV 0x8593 +#define GL_OPERAND3_ALPHA_NV 0x859B + +#define GLEW_NV_texture_env_combine4 GLEW_GET_VAR(__GLEW_NV_texture_env_combine4) + +#endif /* GL_NV_texture_env_combine4 */ + +/* ---------------------- GL_NV_texture_expand_normal ---------------------- */ + +#ifndef GL_NV_texture_expand_normal +#define GL_NV_texture_expand_normal 1 + +#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F + +#define GLEW_NV_texture_expand_normal GLEW_GET_VAR(__GLEW_NV_texture_expand_normal) + +#endif /* GL_NV_texture_expand_normal */ + +/* ----------------------- GL_NV_texture_multisample ----------------------- */ + +#ifndef GL_NV_texture_multisample +#define GL_NV_texture_multisample 1 + +#define GL_TEXTURE_COVERAGE_SAMPLES_NV 0x9045 +#define GL_TEXTURE_COLOR_SAMPLES_NV 0x9046 + +typedef void (GLAPIENTRY * PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC) (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC) (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC) (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); + +#define glTexImage2DMultisampleCoverageNV GLEW_GET_FUN(__glewTexImage2DMultisampleCoverageNV) +#define glTexImage3DMultisampleCoverageNV GLEW_GET_FUN(__glewTexImage3DMultisampleCoverageNV) +#define glTextureImage2DMultisampleCoverageNV GLEW_GET_FUN(__glewTextureImage2DMultisampleCoverageNV) +#define glTextureImage2DMultisampleNV GLEW_GET_FUN(__glewTextureImage2DMultisampleNV) +#define glTextureImage3DMultisampleCoverageNV GLEW_GET_FUN(__glewTextureImage3DMultisampleCoverageNV) +#define glTextureImage3DMultisampleNV GLEW_GET_FUN(__glewTextureImage3DMultisampleNV) + +#define GLEW_NV_texture_multisample GLEW_GET_VAR(__GLEW_NV_texture_multisample) + +#endif /* GL_NV_texture_multisample */ + +/* ------------------------ GL_NV_texture_rectangle ------------------------ */ + +#ifndef GL_NV_texture_rectangle +#define GL_NV_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_NV 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 + +#define GLEW_NV_texture_rectangle GLEW_GET_VAR(__GLEW_NV_texture_rectangle) + +#endif /* GL_NV_texture_rectangle */ + +/* -------------------------- GL_NV_texture_shader ------------------------- */ + +#ifndef GL_NV_texture_shader +#define GL_NV_texture_shader 1 + +#define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C +#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D +#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E +#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 +#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA +#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB +#define GL_DSDT_MAG_INTENSITY_NV 0x86DC +#define GL_SHADER_CONSISTENT_NV 0x86DD +#define GL_TEXTURE_SHADER_NV 0x86DE +#define GL_SHADER_OPERATION_NV 0x86DF +#define GL_CULL_MODES_NV 0x86E0 +#define GL_OFFSET_TEXTURE_2D_MATRIX_NV 0x86E1 +#define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1 +#define GL_OFFSET_TEXTURE_2D_SCALE_NV 0x86E2 +#define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2 +#define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3 +#define GL_OFFSET_TEXTURE_2D_BIAS_NV 0x86E3 +#define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4 +#define GL_CONST_EYE_NV 0x86E5 +#define GL_PASS_THROUGH_NV 0x86E6 +#define GL_CULL_FRAGMENT_NV 0x86E7 +#define GL_OFFSET_TEXTURE_2D_NV 0x86E8 +#define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 +#define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA +#define GL_DOT_PRODUCT_NV 0x86EC +#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED +#define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE +#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 +#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 +#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 +#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 +#define GL_HILO_NV 0x86F4 +#define GL_DSDT_NV 0x86F5 +#define GL_DSDT_MAG_NV 0x86F6 +#define GL_DSDT_MAG_VIB_NV 0x86F7 +#define GL_HILO16_NV 0x86F8 +#define GL_SIGNED_HILO_NV 0x86F9 +#define GL_SIGNED_HILO16_NV 0x86FA +#define GL_SIGNED_RGBA_NV 0x86FB +#define GL_SIGNED_RGBA8_NV 0x86FC +#define GL_SIGNED_RGB_NV 0x86FE +#define GL_SIGNED_RGB8_NV 0x86FF +#define GL_SIGNED_LUMINANCE_NV 0x8701 +#define GL_SIGNED_LUMINANCE8_NV 0x8702 +#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 +#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 +#define GL_SIGNED_ALPHA_NV 0x8705 +#define GL_SIGNED_ALPHA8_NV 0x8706 +#define GL_SIGNED_INTENSITY_NV 0x8707 +#define GL_SIGNED_INTENSITY8_NV 0x8708 +#define GL_DSDT8_NV 0x8709 +#define GL_DSDT8_MAG8_NV 0x870A +#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B +#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C +#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D +#define GL_HI_SCALE_NV 0x870E +#define GL_LO_SCALE_NV 0x870F +#define GL_DS_SCALE_NV 0x8710 +#define GL_DT_SCALE_NV 0x8711 +#define GL_MAGNITUDE_SCALE_NV 0x8712 +#define GL_VIBRANCE_SCALE_NV 0x8713 +#define GL_HI_BIAS_NV 0x8714 +#define GL_LO_BIAS_NV 0x8715 +#define GL_DS_BIAS_NV 0x8716 +#define GL_DT_BIAS_NV 0x8717 +#define GL_MAGNITUDE_BIAS_NV 0x8718 +#define GL_VIBRANCE_BIAS_NV 0x8719 +#define GL_TEXTURE_BORDER_VALUES_NV 0x871A +#define GL_TEXTURE_HI_SIZE_NV 0x871B +#define GL_TEXTURE_LO_SIZE_NV 0x871C +#define GL_TEXTURE_DS_SIZE_NV 0x871D +#define GL_TEXTURE_DT_SIZE_NV 0x871E +#define GL_TEXTURE_MAG_SIZE_NV 0x871F + +#define GLEW_NV_texture_shader GLEW_GET_VAR(__GLEW_NV_texture_shader) + +#endif /* GL_NV_texture_shader */ + +/* ------------------------- GL_NV_texture_shader2 ------------------------- */ + +#ifndef GL_NV_texture_shader2 +#define GL_NV_texture_shader2 1 + +#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA +#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB +#define GL_DSDT_MAG_INTENSITY_NV 0x86DC +#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF +#define GL_HILO_NV 0x86F4 +#define GL_DSDT_NV 0x86F5 +#define GL_DSDT_MAG_NV 0x86F6 +#define GL_DSDT_MAG_VIB_NV 0x86F7 +#define GL_HILO16_NV 0x86F8 +#define GL_SIGNED_HILO_NV 0x86F9 +#define GL_SIGNED_HILO16_NV 0x86FA +#define GL_SIGNED_RGBA_NV 0x86FB +#define GL_SIGNED_RGBA8_NV 0x86FC +#define GL_SIGNED_RGB_NV 0x86FE +#define GL_SIGNED_RGB8_NV 0x86FF +#define GL_SIGNED_LUMINANCE_NV 0x8701 +#define GL_SIGNED_LUMINANCE8_NV 0x8702 +#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 +#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 +#define GL_SIGNED_ALPHA_NV 0x8705 +#define GL_SIGNED_ALPHA8_NV 0x8706 +#define GL_SIGNED_INTENSITY_NV 0x8707 +#define GL_SIGNED_INTENSITY8_NV 0x8708 +#define GL_DSDT8_NV 0x8709 +#define GL_DSDT8_MAG8_NV 0x870A +#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B +#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C +#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D + +#define GLEW_NV_texture_shader2 GLEW_GET_VAR(__GLEW_NV_texture_shader2) + +#endif /* GL_NV_texture_shader2 */ + +/* ------------------------- GL_NV_texture_shader3 ------------------------- */ + +#ifndef GL_NV_texture_shader3 +#define GL_NV_texture_shader3 1 + +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850 +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853 +#define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854 +#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857 +#define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858 +#define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859 +#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A +#define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B +#define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C +#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D +#define GL_HILO8_NV 0x885E +#define GL_SIGNED_HILO8_NV 0x885F +#define GL_FORCE_BLUE_TO_ONE_NV 0x8860 + +#define GLEW_NV_texture_shader3 GLEW_GET_VAR(__GLEW_NV_texture_shader3) + +#endif /* GL_NV_texture_shader3 */ + +/* ------------------------ GL_NV_transform_feedback ----------------------- */ + +#ifndef GL_NV_transform_feedback +#define GL_NV_transform_feedback 1 + +#define GL_BACK_PRIMARY_COLOR_NV 0x8C77 +#define GL_BACK_SECONDARY_COLOR_NV 0x8C78 +#define GL_TEXTURE_COORD_NV 0x8C79 +#define GL_CLIP_DISTANCE_NV 0x8C7A +#define GL_VERTEX_ID_NV 0x8C7B +#define GL_PRIMITIVE_ID_NV 0x8C7C +#define GL_GENERIC_ATTRIB_NV 0x8C7D +#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV 0x8C7E +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80 +#define GL_ACTIVE_VARYINGS_NV 0x8C81 +#define GL_ACTIVE_VARYING_MAX_LENGTH_NV 0x8C82 +#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85 +#define GL_TRANSFORM_FEEDBACK_RECORD_NV 0x8C86 +#define GL_PRIMITIVES_GENERATED_NV 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88 +#define GL_RASTERIZER_DISCARD_NV 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B +#define GL_INTERLEAVED_ATTRIBS_NV 0x8C8C +#define GL_SEPARATE_ATTRIBS_NV 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER_NV 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F + +typedef void (GLAPIENTRY * PFNGLACTIVEVARYINGNVPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASENVPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKNVPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint program, GLuint index, GLint *location); +typedef GLint (GLAPIENTRY * PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLuint count, const GLint *attribs, GLenum bufferMode); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode); + +#define glActiveVaryingNV GLEW_GET_FUN(__glewActiveVaryingNV) +#define glBeginTransformFeedbackNV GLEW_GET_FUN(__glewBeginTransformFeedbackNV) +#define glBindBufferBaseNV GLEW_GET_FUN(__glewBindBufferBaseNV) +#define glBindBufferOffsetNV GLEW_GET_FUN(__glewBindBufferOffsetNV) +#define glBindBufferRangeNV GLEW_GET_FUN(__glewBindBufferRangeNV) +#define glEndTransformFeedbackNV GLEW_GET_FUN(__glewEndTransformFeedbackNV) +#define glGetActiveVaryingNV GLEW_GET_FUN(__glewGetActiveVaryingNV) +#define glGetTransformFeedbackVaryingNV GLEW_GET_FUN(__glewGetTransformFeedbackVaryingNV) +#define glGetVaryingLocationNV GLEW_GET_FUN(__glewGetVaryingLocationNV) +#define glTransformFeedbackAttribsNV GLEW_GET_FUN(__glewTransformFeedbackAttribsNV) +#define glTransformFeedbackVaryingsNV GLEW_GET_FUN(__glewTransformFeedbackVaryingsNV) + +#define GLEW_NV_transform_feedback GLEW_GET_VAR(__GLEW_NV_transform_feedback) + +#endif /* GL_NV_transform_feedback */ + +/* ----------------------- GL_NV_transform_feedback2 ----------------------- */ + +#ifndef GL_NV_transform_feedback2 +#define GL_NV_transform_feedback2 1 + +#define GL_TRANSFORM_FEEDBACK_NV 0x8E22 +#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV 0x8E23 +#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV 0x8E24 +#define GL_TRANSFORM_FEEDBACK_BINDING_NV 0x8E25 + +typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKNVPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSNVPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKNVPROC) (GLenum mode, GLuint id); +typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSNVPROC) (GLsizei n, GLuint* ids); +typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKNVPROC) (void); +typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void); + +#define glBindTransformFeedbackNV GLEW_GET_FUN(__glewBindTransformFeedbackNV) +#define glDeleteTransformFeedbacksNV GLEW_GET_FUN(__glewDeleteTransformFeedbacksNV) +#define glDrawTransformFeedbackNV GLEW_GET_FUN(__glewDrawTransformFeedbackNV) +#define glGenTransformFeedbacksNV GLEW_GET_FUN(__glewGenTransformFeedbacksNV) +#define glIsTransformFeedbackNV GLEW_GET_FUN(__glewIsTransformFeedbackNV) +#define glPauseTransformFeedbackNV GLEW_GET_FUN(__glewPauseTransformFeedbackNV) +#define glResumeTransformFeedbackNV GLEW_GET_FUN(__glewResumeTransformFeedbackNV) + +#define GLEW_NV_transform_feedback2 GLEW_GET_VAR(__GLEW_NV_transform_feedback2) + +#endif /* GL_NV_transform_feedback2 */ + +/* -------------------------- GL_NV_vdpau_interop -------------------------- */ + +#ifndef GL_NV_vdpau_interop +#define GL_NV_vdpau_interop 1 + +#define GL_SURFACE_STATE_NV 0x86EB +#define GL_SURFACE_REGISTERED_NV 0x86FD +#define GL_SURFACE_MAPPED_NV 0x8700 +#define GL_WRITE_DISCARD_NV 0x88BE + +typedef GLintptr GLvdpauSurfaceNV; + +typedef void (GLAPIENTRY * PFNGLVDPAUFININVPROC) (void); +typedef void (GLAPIENTRY * PFNGLVDPAUGETSURFACEIVNVPROC) (GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei* length, GLint *values); +typedef void (GLAPIENTRY * PFNGLVDPAUINITNVPROC) (const void* vdpDevice, const GLvoid*getProcAddress); +typedef void (GLAPIENTRY * PFNGLVDPAUISSURFACENVPROC) (GLvdpauSurfaceNV surface); +typedef void (GLAPIENTRY * PFNGLVDPAUMAPSURFACESNVPROC) (GLsizei numSurfaces, const GLvdpauSurfaceNV* surfaces); +typedef GLvdpauSurfaceNV (GLAPIENTRY * PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC) (const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames); +typedef GLvdpauSurfaceNV (GLAPIENTRY * PFNGLVDPAUREGISTERVIDEOSURFACENVPROC) (const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames); +typedef void (GLAPIENTRY * PFNGLVDPAUSURFACEACCESSNVPROC) (GLvdpauSurfaceNV surface, GLenum access); +typedef void (GLAPIENTRY * PFNGLVDPAUUNMAPSURFACESNVPROC) (GLsizei numSurface, const GLvdpauSurfaceNV* surfaces); +typedef void (GLAPIENTRY * PFNGLVDPAUUNREGISTERSURFACENVPROC) (GLvdpauSurfaceNV surface); + +#define glVDPAUFiniNV GLEW_GET_FUN(__glewVDPAUFiniNV) +#define glVDPAUGetSurfaceivNV GLEW_GET_FUN(__glewVDPAUGetSurfaceivNV) +#define glVDPAUInitNV GLEW_GET_FUN(__glewVDPAUInitNV) +#define glVDPAUIsSurfaceNV GLEW_GET_FUN(__glewVDPAUIsSurfaceNV) +#define glVDPAUMapSurfacesNV GLEW_GET_FUN(__glewVDPAUMapSurfacesNV) +#define glVDPAURegisterOutputSurfaceNV GLEW_GET_FUN(__glewVDPAURegisterOutputSurfaceNV) +#define glVDPAURegisterVideoSurfaceNV GLEW_GET_FUN(__glewVDPAURegisterVideoSurfaceNV) +#define glVDPAUSurfaceAccessNV GLEW_GET_FUN(__glewVDPAUSurfaceAccessNV) +#define glVDPAUUnmapSurfacesNV GLEW_GET_FUN(__glewVDPAUUnmapSurfacesNV) +#define glVDPAUUnregisterSurfaceNV GLEW_GET_FUN(__glewVDPAUUnregisterSurfaceNV) + +#define GLEW_NV_vdpau_interop GLEW_GET_VAR(__GLEW_NV_vdpau_interop) + +#endif /* GL_NV_vdpau_interop */ + +/* ------------------------ GL_NV_vertex_array_range ----------------------- */ + +#ifndef GL_NV_vertex_array_range +#define GL_NV_vertex_array_range 1 + +#define GL_VERTEX_ARRAY_RANGE_NV 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E +#define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F +#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520 +#define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521 + +typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, void* pointer); + +#define glFlushVertexArrayRangeNV GLEW_GET_FUN(__glewFlushVertexArrayRangeNV) +#define glVertexArrayRangeNV GLEW_GET_FUN(__glewVertexArrayRangeNV) + +#define GLEW_NV_vertex_array_range GLEW_GET_VAR(__GLEW_NV_vertex_array_range) + +#endif /* GL_NV_vertex_array_range */ + +/* ----------------------- GL_NV_vertex_array_range2 ----------------------- */ + +#ifndef GL_NV_vertex_array_range2 +#define GL_NV_vertex_array_range2 1 + +#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533 + +#define GLEW_NV_vertex_array_range2 GLEW_GET_VAR(__GLEW_NV_vertex_array_range2) + +#endif /* GL_NV_vertex_array_range2 */ + +/* ------------------- GL_NV_vertex_attrib_integer_64bit ------------------- */ + +#ifndef GL_NV_vertex_attrib_integer_64bit +#define GL_NV_vertex_attrib_integer_64bit 1 + +#define GL_INT64_NV 0x140E +#define GL_UNSIGNED_INT64_NV 0x140F + +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLI64VNVPROC) (GLuint index, GLenum pname, GLint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLUI64VNVPROC) (GLuint index, GLenum pname, GLuint64EXT* params); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64NVPROC) (GLuint index, GLint64EXT x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64VNVPROC) (GLuint index, const GLint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64NVPROC) (GLuint index, GLuint64EXT x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64VNVPROC) (GLuint index, const GLuint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64VNVPROC) (GLuint index, const GLint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64VNVPROC) (GLuint index, const GLuint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64VNVPROC) (GLuint index, const GLint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64VNVPROC) (GLuint index, const GLuint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64VNVPROC) (GLuint index, const GLint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64VNVPROC) (GLuint index, const GLuint64EXT* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride); + +#define glGetVertexAttribLi64vNV GLEW_GET_FUN(__glewGetVertexAttribLi64vNV) +#define glGetVertexAttribLui64vNV GLEW_GET_FUN(__glewGetVertexAttribLui64vNV) +#define glVertexAttribL1i64NV GLEW_GET_FUN(__glewVertexAttribL1i64NV) +#define glVertexAttribL1i64vNV GLEW_GET_FUN(__glewVertexAttribL1i64vNV) +#define glVertexAttribL1ui64NV GLEW_GET_FUN(__glewVertexAttribL1ui64NV) +#define glVertexAttribL1ui64vNV GLEW_GET_FUN(__glewVertexAttribL1ui64vNV) +#define glVertexAttribL2i64NV GLEW_GET_FUN(__glewVertexAttribL2i64NV) +#define glVertexAttribL2i64vNV GLEW_GET_FUN(__glewVertexAttribL2i64vNV) +#define glVertexAttribL2ui64NV GLEW_GET_FUN(__glewVertexAttribL2ui64NV) +#define glVertexAttribL2ui64vNV GLEW_GET_FUN(__glewVertexAttribL2ui64vNV) +#define glVertexAttribL3i64NV GLEW_GET_FUN(__glewVertexAttribL3i64NV) +#define glVertexAttribL3i64vNV GLEW_GET_FUN(__glewVertexAttribL3i64vNV) +#define glVertexAttribL3ui64NV GLEW_GET_FUN(__glewVertexAttribL3ui64NV) +#define glVertexAttribL3ui64vNV GLEW_GET_FUN(__glewVertexAttribL3ui64vNV) +#define glVertexAttribL4i64NV GLEW_GET_FUN(__glewVertexAttribL4i64NV) +#define glVertexAttribL4i64vNV GLEW_GET_FUN(__glewVertexAttribL4i64vNV) +#define glVertexAttribL4ui64NV GLEW_GET_FUN(__glewVertexAttribL4ui64NV) +#define glVertexAttribL4ui64vNV GLEW_GET_FUN(__glewVertexAttribL4ui64vNV) +#define glVertexAttribLFormatNV GLEW_GET_FUN(__glewVertexAttribLFormatNV) + +#define GLEW_NV_vertex_attrib_integer_64bit GLEW_GET_VAR(__GLEW_NV_vertex_attrib_integer_64bit) + +#endif /* GL_NV_vertex_attrib_integer_64bit */ + +/* ------------------- GL_NV_vertex_buffer_unified_memory ------------------ */ + +#ifndef GL_NV_vertex_buffer_unified_memory +#define GL_NV_vertex_buffer_unified_memory 1 + +#define GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV 0x8F1E +#define GL_ELEMENT_ARRAY_UNIFIED_NV 0x8F1F +#define GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV 0x8F20 +#define GL_VERTEX_ARRAY_ADDRESS_NV 0x8F21 +#define GL_NORMAL_ARRAY_ADDRESS_NV 0x8F22 +#define GL_COLOR_ARRAY_ADDRESS_NV 0x8F23 +#define GL_INDEX_ARRAY_ADDRESS_NV 0x8F24 +#define GL_TEXTURE_COORD_ARRAY_ADDRESS_NV 0x8F25 +#define GL_EDGE_FLAG_ARRAY_ADDRESS_NV 0x8F26 +#define GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV 0x8F27 +#define GL_FOG_COORD_ARRAY_ADDRESS_NV 0x8F28 +#define GL_ELEMENT_ARRAY_ADDRESS_NV 0x8F29 +#define GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV 0x8F2A +#define GL_VERTEX_ARRAY_LENGTH_NV 0x8F2B +#define GL_NORMAL_ARRAY_LENGTH_NV 0x8F2C +#define GL_COLOR_ARRAY_LENGTH_NV 0x8F2D +#define GL_INDEX_ARRAY_LENGTH_NV 0x8F2E +#define GL_TEXTURE_COORD_ARRAY_LENGTH_NV 0x8F2F +#define GL_EDGE_FLAG_ARRAY_LENGTH_NV 0x8F30 +#define GL_SECONDARY_COLOR_ARRAY_LENGTH_NV 0x8F31 +#define GL_FOG_COORD_ARRAY_LENGTH_NV 0x8F32 +#define GL_ELEMENT_ARRAY_LENGTH_NV 0x8F33 +#define GL_DRAW_INDIRECT_UNIFIED_NV 0x8F40 +#define GL_DRAW_INDIRECT_ADDRESS_NV 0x8F41 +#define GL_DRAW_INDIRECT_LENGTH_NV 0x8F42 + +typedef void (GLAPIENTRY * PFNGLBUFFERADDRESSRANGENVPROC) (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length); +typedef void (GLAPIENTRY * PFNGLCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGFORMATNVPROC) (GLsizei stride); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFORMATNVPROC) (GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT result[]); +typedef void (GLAPIENTRY * PFNGLINDEXFORMATNVPROC) (GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLNORMALFORMATNVPROC) (GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLTEXCOORDFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLVERTEXFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); + +#define glBufferAddressRangeNV GLEW_GET_FUN(__glewBufferAddressRangeNV) +#define glColorFormatNV GLEW_GET_FUN(__glewColorFormatNV) +#define glEdgeFlagFormatNV GLEW_GET_FUN(__glewEdgeFlagFormatNV) +#define glFogCoordFormatNV GLEW_GET_FUN(__glewFogCoordFormatNV) +#define glGetIntegerui64i_vNV GLEW_GET_FUN(__glewGetIntegerui64i_vNV) +#define glIndexFormatNV GLEW_GET_FUN(__glewIndexFormatNV) +#define glNormalFormatNV GLEW_GET_FUN(__glewNormalFormatNV) +#define glSecondaryColorFormatNV GLEW_GET_FUN(__glewSecondaryColorFormatNV) +#define glTexCoordFormatNV GLEW_GET_FUN(__glewTexCoordFormatNV) +#define glVertexAttribFormatNV GLEW_GET_FUN(__glewVertexAttribFormatNV) +#define glVertexAttribIFormatNV GLEW_GET_FUN(__glewVertexAttribIFormatNV) +#define glVertexFormatNV GLEW_GET_FUN(__glewVertexFormatNV) + +#define GLEW_NV_vertex_buffer_unified_memory GLEW_GET_VAR(__GLEW_NV_vertex_buffer_unified_memory) + +#endif /* GL_NV_vertex_buffer_unified_memory */ + +/* -------------------------- GL_NV_vertex_program ------------------------- */ + +#ifndef GL_NV_vertex_program +#define GL_NV_vertex_program 1 + +#define GL_VERTEX_PROGRAM_NV 0x8620 +#define GL_VERTEX_STATE_PROGRAM_NV 0x8621 +#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 +#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 +#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 +#define GL_CURRENT_ATTRIB_NV 0x8626 +#define GL_PROGRAM_LENGTH_NV 0x8627 +#define GL_PROGRAM_STRING_NV 0x8628 +#define GL_MODELVIEW_PROJECTION_NV 0x8629 +#define GL_IDENTITY_NV 0x862A +#define GL_INVERSE_NV 0x862B +#define GL_TRANSPOSE_NV 0x862C +#define GL_INVERSE_TRANSPOSE_NV 0x862D +#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E +#define GL_MAX_TRACK_MATRICES_NV 0x862F +#define GL_MATRIX0_NV 0x8630 +#define GL_MATRIX1_NV 0x8631 +#define GL_MATRIX2_NV 0x8632 +#define GL_MATRIX3_NV 0x8633 +#define GL_MATRIX4_NV 0x8634 +#define GL_MATRIX5_NV 0x8635 +#define GL_MATRIX6_NV 0x8636 +#define GL_MATRIX7_NV 0x8637 +#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 +#define GL_CURRENT_MATRIX_NV 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 +#define GL_PROGRAM_PARAMETER_NV 0x8644 +#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 +#define GL_PROGRAM_TARGET_NV 0x8646 +#define GL_PROGRAM_RESIDENT_NV 0x8647 +#define GL_TRACK_MATRIX_NV 0x8648 +#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 +#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A +#define GL_PROGRAM_ERROR_POSITION_NV 0x864B +#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 +#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 +#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 +#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 +#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 +#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 +#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 +#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 +#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 +#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 +#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A +#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B +#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C +#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D +#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E +#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F +#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 +#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 +#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 +#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 +#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 +#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 +#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 +#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 +#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 +#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 +#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A +#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B +#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C +#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D +#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E +#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F +#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 +#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 +#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 +#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 +#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 +#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 +#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 +#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 +#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 +#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 +#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A +#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B +#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C +#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D +#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E +#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F + +typedef GLboolean (GLAPIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint* ids, GLboolean *residences); +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte* program); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte* program); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLsizei num, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLsizei num, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei n, const GLubyte* v); + +#define glAreProgramsResidentNV GLEW_GET_FUN(__glewAreProgramsResidentNV) +#define glBindProgramNV GLEW_GET_FUN(__glewBindProgramNV) +#define glDeleteProgramsNV GLEW_GET_FUN(__glewDeleteProgramsNV) +#define glExecuteProgramNV GLEW_GET_FUN(__glewExecuteProgramNV) +#define glGenProgramsNV GLEW_GET_FUN(__glewGenProgramsNV) +#define glGetProgramParameterdvNV GLEW_GET_FUN(__glewGetProgramParameterdvNV) +#define glGetProgramParameterfvNV GLEW_GET_FUN(__glewGetProgramParameterfvNV) +#define glGetProgramStringNV GLEW_GET_FUN(__glewGetProgramStringNV) +#define glGetProgramivNV GLEW_GET_FUN(__glewGetProgramivNV) +#define glGetTrackMatrixivNV GLEW_GET_FUN(__glewGetTrackMatrixivNV) +#define glGetVertexAttribPointervNV GLEW_GET_FUN(__glewGetVertexAttribPointervNV) +#define glGetVertexAttribdvNV GLEW_GET_FUN(__glewGetVertexAttribdvNV) +#define glGetVertexAttribfvNV GLEW_GET_FUN(__glewGetVertexAttribfvNV) +#define glGetVertexAttribivNV GLEW_GET_FUN(__glewGetVertexAttribivNV) +#define glIsProgramNV GLEW_GET_FUN(__glewIsProgramNV) +#define glLoadProgramNV GLEW_GET_FUN(__glewLoadProgramNV) +#define glProgramParameter4dNV GLEW_GET_FUN(__glewProgramParameter4dNV) +#define glProgramParameter4dvNV GLEW_GET_FUN(__glewProgramParameter4dvNV) +#define glProgramParameter4fNV GLEW_GET_FUN(__glewProgramParameter4fNV) +#define glProgramParameter4fvNV GLEW_GET_FUN(__glewProgramParameter4fvNV) +#define glProgramParameters4dvNV GLEW_GET_FUN(__glewProgramParameters4dvNV) +#define glProgramParameters4fvNV GLEW_GET_FUN(__glewProgramParameters4fvNV) +#define glRequestResidentProgramsNV GLEW_GET_FUN(__glewRequestResidentProgramsNV) +#define glTrackMatrixNV GLEW_GET_FUN(__glewTrackMatrixNV) +#define glVertexAttrib1dNV GLEW_GET_FUN(__glewVertexAttrib1dNV) +#define glVertexAttrib1dvNV GLEW_GET_FUN(__glewVertexAttrib1dvNV) +#define glVertexAttrib1fNV GLEW_GET_FUN(__glewVertexAttrib1fNV) +#define glVertexAttrib1fvNV GLEW_GET_FUN(__glewVertexAttrib1fvNV) +#define glVertexAttrib1sNV GLEW_GET_FUN(__glewVertexAttrib1sNV) +#define glVertexAttrib1svNV GLEW_GET_FUN(__glewVertexAttrib1svNV) +#define glVertexAttrib2dNV GLEW_GET_FUN(__glewVertexAttrib2dNV) +#define glVertexAttrib2dvNV GLEW_GET_FUN(__glewVertexAttrib2dvNV) +#define glVertexAttrib2fNV GLEW_GET_FUN(__glewVertexAttrib2fNV) +#define glVertexAttrib2fvNV GLEW_GET_FUN(__glewVertexAttrib2fvNV) +#define glVertexAttrib2sNV GLEW_GET_FUN(__glewVertexAttrib2sNV) +#define glVertexAttrib2svNV GLEW_GET_FUN(__glewVertexAttrib2svNV) +#define glVertexAttrib3dNV GLEW_GET_FUN(__glewVertexAttrib3dNV) +#define glVertexAttrib3dvNV GLEW_GET_FUN(__glewVertexAttrib3dvNV) +#define glVertexAttrib3fNV GLEW_GET_FUN(__glewVertexAttrib3fNV) +#define glVertexAttrib3fvNV GLEW_GET_FUN(__glewVertexAttrib3fvNV) +#define glVertexAttrib3sNV GLEW_GET_FUN(__glewVertexAttrib3sNV) +#define glVertexAttrib3svNV GLEW_GET_FUN(__glewVertexAttrib3svNV) +#define glVertexAttrib4dNV GLEW_GET_FUN(__glewVertexAttrib4dNV) +#define glVertexAttrib4dvNV GLEW_GET_FUN(__glewVertexAttrib4dvNV) +#define glVertexAttrib4fNV GLEW_GET_FUN(__glewVertexAttrib4fNV) +#define glVertexAttrib4fvNV GLEW_GET_FUN(__glewVertexAttrib4fvNV) +#define glVertexAttrib4sNV GLEW_GET_FUN(__glewVertexAttrib4sNV) +#define glVertexAttrib4svNV GLEW_GET_FUN(__glewVertexAttrib4svNV) +#define glVertexAttrib4ubNV GLEW_GET_FUN(__glewVertexAttrib4ubNV) +#define glVertexAttrib4ubvNV GLEW_GET_FUN(__glewVertexAttrib4ubvNV) +#define glVertexAttribPointerNV GLEW_GET_FUN(__glewVertexAttribPointerNV) +#define glVertexAttribs1dvNV GLEW_GET_FUN(__glewVertexAttribs1dvNV) +#define glVertexAttribs1fvNV GLEW_GET_FUN(__glewVertexAttribs1fvNV) +#define glVertexAttribs1svNV GLEW_GET_FUN(__glewVertexAttribs1svNV) +#define glVertexAttribs2dvNV GLEW_GET_FUN(__glewVertexAttribs2dvNV) +#define glVertexAttribs2fvNV GLEW_GET_FUN(__glewVertexAttribs2fvNV) +#define glVertexAttribs2svNV GLEW_GET_FUN(__glewVertexAttribs2svNV) +#define glVertexAttribs3dvNV GLEW_GET_FUN(__glewVertexAttribs3dvNV) +#define glVertexAttribs3fvNV GLEW_GET_FUN(__glewVertexAttribs3fvNV) +#define glVertexAttribs3svNV GLEW_GET_FUN(__glewVertexAttribs3svNV) +#define glVertexAttribs4dvNV GLEW_GET_FUN(__glewVertexAttribs4dvNV) +#define glVertexAttribs4fvNV GLEW_GET_FUN(__glewVertexAttribs4fvNV) +#define glVertexAttribs4svNV GLEW_GET_FUN(__glewVertexAttribs4svNV) +#define glVertexAttribs4ubvNV GLEW_GET_FUN(__glewVertexAttribs4ubvNV) + +#define GLEW_NV_vertex_program GLEW_GET_VAR(__GLEW_NV_vertex_program) + +#endif /* GL_NV_vertex_program */ + +/* ------------------------ GL_NV_vertex_program1_1 ------------------------ */ + +#ifndef GL_NV_vertex_program1_1 +#define GL_NV_vertex_program1_1 1 + +#define GLEW_NV_vertex_program1_1 GLEW_GET_VAR(__GLEW_NV_vertex_program1_1) + +#endif /* GL_NV_vertex_program1_1 */ + +/* ------------------------- GL_NV_vertex_program2 ------------------------- */ + +#ifndef GL_NV_vertex_program2 +#define GL_NV_vertex_program2 1 + +#define GLEW_NV_vertex_program2 GLEW_GET_VAR(__GLEW_NV_vertex_program2) + +#endif /* GL_NV_vertex_program2 */ + +/* ---------------------- GL_NV_vertex_program2_option --------------------- */ + +#ifndef GL_NV_vertex_program2_option +#define GL_NV_vertex_program2_option 1 + +#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 +#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 + +#define GLEW_NV_vertex_program2_option GLEW_GET_VAR(__GLEW_NV_vertex_program2_option) + +#endif /* GL_NV_vertex_program2_option */ + +/* ------------------------- GL_NV_vertex_program3 ------------------------- */ + +#ifndef GL_NV_vertex_program3 +#define GL_NV_vertex_program3 1 + +#define MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C + +#define GLEW_NV_vertex_program3 GLEW_GET_VAR(__GLEW_NV_vertex_program3) + +#endif /* GL_NV_vertex_program3 */ + +/* ------------------------- GL_NV_vertex_program4 ------------------------- */ + +#ifndef GL_NV_vertex_program4 +#define GL_NV_vertex_program4 1 + +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV 0x88FD + +#define GLEW_NV_vertex_program4 GLEW_GET_VAR(__GLEW_NV_vertex_program4) + +#endif /* GL_NV_vertex_program4 */ + +/* -------------------------- GL_NV_video_capture -------------------------- */ + +#ifndef GL_NV_video_capture +#define GL_NV_video_capture 1 + +#define GL_VIDEO_BUFFER_NV 0x9020 +#define GL_VIDEO_BUFFER_BINDING_NV 0x9021 +#define GL_FIELD_UPPER_NV 0x9022 +#define GL_FIELD_LOWER_NV 0x9023 +#define GL_NUM_VIDEO_CAPTURE_STREAMS_NV 0x9024 +#define GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV 0x9025 +#define GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV 0x9026 +#define GL_LAST_VIDEO_CAPTURE_STATUS_NV 0x9027 +#define GL_VIDEO_BUFFER_PITCH_NV 0x9028 +#define GL_VIDEO_COLOR_CONVERSION_MATRIX_NV 0x9029 +#define GL_VIDEO_COLOR_CONVERSION_MAX_NV 0x902A +#define GL_VIDEO_COLOR_CONVERSION_MIN_NV 0x902B +#define GL_VIDEO_COLOR_CONVERSION_OFFSET_NV 0x902C +#define GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV 0x902D +#define GL_PARTIAL_SUCCESS_NV 0x902E +#define GL_SUCCESS_NV 0x902F +#define GL_FAILURE_NV 0x9030 +#define GL_YCBYCR8_422_NV 0x9031 +#define GL_YCBAYCR8A_4224_NV 0x9032 +#define GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV 0x9033 +#define GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV 0x9034 +#define GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV 0x9035 +#define GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV 0x9036 +#define GL_Z4Y12Z4CB12Z4CR12_444_NV 0x9037 +#define GL_VIDEO_CAPTURE_FRAME_WIDTH_NV 0x9038 +#define GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV 0x9039 +#define GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV 0x903A +#define GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV 0x903B +#define GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV 0x903C + +typedef void (GLAPIENTRY * PFNGLBEGINVIDEOCAPTURENVPROC) (GLuint video_capture_slot); +typedef void (GLAPIENTRY * PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset); +typedef void (GLAPIENTRY * PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture); +typedef void (GLAPIENTRY * PFNGLENDVIDEOCAPTURENVPROC) (GLuint video_capture_slot); +typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTUREIVNVPROC) (GLuint video_capture_slot, GLenum pname, GLint* params); +typedef GLenum (GLAPIENTRY * PFNGLVIDEOCAPTURENVPROC) (GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT *capture_time); +typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params); + +#define glBeginVideoCaptureNV GLEW_GET_FUN(__glewBeginVideoCaptureNV) +#define glBindVideoCaptureStreamBufferNV GLEW_GET_FUN(__glewBindVideoCaptureStreamBufferNV) +#define glBindVideoCaptureStreamTextureNV GLEW_GET_FUN(__glewBindVideoCaptureStreamTextureNV) +#define glEndVideoCaptureNV GLEW_GET_FUN(__glewEndVideoCaptureNV) +#define glGetVideoCaptureStreamdvNV GLEW_GET_FUN(__glewGetVideoCaptureStreamdvNV) +#define glGetVideoCaptureStreamfvNV GLEW_GET_FUN(__glewGetVideoCaptureStreamfvNV) +#define glGetVideoCaptureStreamivNV GLEW_GET_FUN(__glewGetVideoCaptureStreamivNV) +#define glGetVideoCaptureivNV GLEW_GET_FUN(__glewGetVideoCaptureivNV) +#define glVideoCaptureNV GLEW_GET_FUN(__glewVideoCaptureNV) +#define glVideoCaptureStreamParameterdvNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterdvNV) +#define glVideoCaptureStreamParameterfvNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterfvNV) +#define glVideoCaptureStreamParameterivNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterivNV) + +#define GLEW_NV_video_capture GLEW_GET_VAR(__GLEW_NV_video_capture) + +#endif /* GL_NV_video_capture */ + +/* ------------------------ GL_OES_byte_coordinates ------------------------ */ + +#ifndef GL_OES_byte_coordinates +#define GL_OES_byte_coordinates 1 + +#define GL_BYTE 0x1400 + +#define GLEW_OES_byte_coordinates GLEW_GET_VAR(__GLEW_OES_byte_coordinates) + +#endif /* GL_OES_byte_coordinates */ + +/* ------------------- GL_OES_compressed_paletted_texture ------------------ */ + +#ifndef GL_OES_compressed_paletted_texture +#define GL_OES_compressed_paletted_texture 1 + +#define GL_PALETTE4_RGB8_OES 0x8B90 +#define GL_PALETTE4_RGBA8_OES 0x8B91 +#define GL_PALETTE4_R5_G6_B5_OES 0x8B92 +#define GL_PALETTE4_RGBA4_OES 0x8B93 +#define GL_PALETTE4_RGB5_A1_OES 0x8B94 +#define GL_PALETTE8_RGB8_OES 0x8B95 +#define GL_PALETTE8_RGBA8_OES 0x8B96 +#define GL_PALETTE8_R5_G6_B5_OES 0x8B97 +#define GL_PALETTE8_RGBA4_OES 0x8B98 +#define GL_PALETTE8_RGB5_A1_OES 0x8B99 + +#define GLEW_OES_compressed_paletted_texture GLEW_GET_VAR(__GLEW_OES_compressed_paletted_texture) + +#endif /* GL_OES_compressed_paletted_texture */ + +/* --------------------------- GL_OES_read_format -------------------------- */ + +#ifndef GL_OES_read_format +#define GL_OES_read_format 1 + +#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B + +#define GLEW_OES_read_format GLEW_GET_VAR(__GLEW_OES_read_format) + +#endif /* GL_OES_read_format */ + +/* ------------------------ GL_OES_single_precision ------------------------ */ + +#ifndef GL_OES_single_precision +#define GL_OES_single_precision 1 + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFOESPROC) (GLclampd depth); +typedef void (GLAPIENTRY * PFNGLCLIPPLANEFOESPROC) (GLenum plane, const GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFOESPROC) (GLclampf n, GLclampf f); +typedef void (GLAPIENTRY * PFNGLFRUSTUMFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); +typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEFOESPROC) (GLenum plane, GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLORTHOFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); + +#define glClearDepthfOES GLEW_GET_FUN(__glewClearDepthfOES) +#define glClipPlanefOES GLEW_GET_FUN(__glewClipPlanefOES) +#define glDepthRangefOES GLEW_GET_FUN(__glewDepthRangefOES) +#define glFrustumfOES GLEW_GET_FUN(__glewFrustumfOES) +#define glGetClipPlanefOES GLEW_GET_FUN(__glewGetClipPlanefOES) +#define glOrthofOES GLEW_GET_FUN(__glewOrthofOES) + +#define GLEW_OES_single_precision GLEW_GET_VAR(__GLEW_OES_single_precision) + +#endif /* GL_OES_single_precision */ + +/* ---------------------------- GL_OML_interlace --------------------------- */ + +#ifndef GL_OML_interlace +#define GL_OML_interlace 1 + +#define GL_INTERLACE_OML 0x8980 +#define GL_INTERLACE_READ_OML 0x8981 + +#define GLEW_OML_interlace GLEW_GET_VAR(__GLEW_OML_interlace) + +#endif /* GL_OML_interlace */ + +/* ---------------------------- GL_OML_resample ---------------------------- */ + +#ifndef GL_OML_resample +#define GL_OML_resample 1 + +#define GL_PACK_RESAMPLE_OML 0x8984 +#define GL_UNPACK_RESAMPLE_OML 0x8985 +#define GL_RESAMPLE_REPLICATE_OML 0x8986 +#define GL_RESAMPLE_ZERO_FILL_OML 0x8987 +#define GL_RESAMPLE_AVERAGE_OML 0x8988 +#define GL_RESAMPLE_DECIMATE_OML 0x8989 + +#define GLEW_OML_resample GLEW_GET_VAR(__GLEW_OML_resample) + +#endif /* GL_OML_resample */ + +/* ---------------------------- GL_OML_subsample --------------------------- */ + +#ifndef GL_OML_subsample +#define GL_OML_subsample 1 + +#define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982 +#define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983 + +#define GLEW_OML_subsample GLEW_GET_VAR(__GLEW_OML_subsample) + +#endif /* GL_OML_subsample */ + +/* --------------------------- GL_PGI_misc_hints --------------------------- */ + +#ifndef GL_PGI_misc_hints +#define GL_PGI_misc_hints 1 + +#define GL_PREFER_DOUBLEBUFFER_HINT_PGI 107000 +#define GL_CONSERVE_MEMORY_HINT_PGI 107005 +#define GL_RECLAIM_MEMORY_HINT_PGI 107006 +#define GL_NATIVE_GRAPHICS_HANDLE_PGI 107010 +#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 107011 +#define GL_NATIVE_GRAPHICS_END_HINT_PGI 107012 +#define GL_ALWAYS_FAST_HINT_PGI 107020 +#define GL_ALWAYS_SOFT_HINT_PGI 107021 +#define GL_ALLOW_DRAW_OBJ_HINT_PGI 107022 +#define GL_ALLOW_DRAW_WIN_HINT_PGI 107023 +#define GL_ALLOW_DRAW_FRG_HINT_PGI 107024 +#define GL_ALLOW_DRAW_MEM_HINT_PGI 107025 +#define GL_STRICT_DEPTHFUNC_HINT_PGI 107030 +#define GL_STRICT_LIGHTING_HINT_PGI 107031 +#define GL_STRICT_SCISSOR_HINT_PGI 107032 +#define GL_FULL_STIPPLE_HINT_PGI 107033 +#define GL_CLIP_NEAR_HINT_PGI 107040 +#define GL_CLIP_FAR_HINT_PGI 107041 +#define GL_WIDE_LINE_HINT_PGI 107042 +#define GL_BACK_NORMALS_HINT_PGI 107043 + +#define GLEW_PGI_misc_hints GLEW_GET_VAR(__GLEW_PGI_misc_hints) + +#endif /* GL_PGI_misc_hints */ + +/* -------------------------- GL_PGI_vertex_hints -------------------------- */ + +#ifndef GL_PGI_vertex_hints +#define GL_PGI_vertex_hints 1 + +#define GL_VERTEX23_BIT_PGI 0x00000004 +#define GL_VERTEX4_BIT_PGI 0x00000008 +#define GL_COLOR3_BIT_PGI 0x00010000 +#define GL_COLOR4_BIT_PGI 0x00020000 +#define GL_EDGEFLAG_BIT_PGI 0x00040000 +#define GL_INDEX_BIT_PGI 0x00080000 +#define GL_MAT_AMBIENT_BIT_PGI 0x00100000 +#define GL_VERTEX_DATA_HINT_PGI 107050 +#define GL_VERTEX_CONSISTENT_HINT_PGI 107051 +#define GL_MATERIAL_SIDE_HINT_PGI 107052 +#define GL_MAX_VERTEX_HINT_PGI 107053 +#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000 +#define GL_MAT_DIFFUSE_BIT_PGI 0x00400000 +#define GL_MAT_EMISSION_BIT_PGI 0x00800000 +#define GL_MAT_COLOR_INDEXES_BIT_PGI 0x01000000 +#define GL_MAT_SHININESS_BIT_PGI 0x02000000 +#define GL_MAT_SPECULAR_BIT_PGI 0x04000000 +#define GL_NORMAL_BIT_PGI 0x08000000 +#define GL_TEXCOORD1_BIT_PGI 0x10000000 +#define GL_TEXCOORD2_BIT_PGI 0x20000000 +#define GL_TEXCOORD3_BIT_PGI 0x40000000 +#define GL_TEXCOORD4_BIT_PGI 0x80000000 + +#define GLEW_PGI_vertex_hints GLEW_GET_VAR(__GLEW_PGI_vertex_hints) + +#endif /* GL_PGI_vertex_hints */ + +/* ----------------------- GL_REND_screen_coordinates ---------------------- */ + +#ifndef GL_REND_screen_coordinates +#define GL_REND_screen_coordinates 1 + +#define GL_SCREEN_COORDINATES_REND 0x8490 +#define GL_INVERTED_SCREEN_W_REND 0x8491 + +#define GLEW_REND_screen_coordinates GLEW_GET_VAR(__GLEW_REND_screen_coordinates) + +#endif /* GL_REND_screen_coordinates */ + +/* ------------------------------- GL_S3_s3tc ------------------------------ */ + +#ifndef GL_S3_s3tc +#define GL_S3_s3tc 1 + +#define GL_RGB_S3TC 0x83A0 +#define GL_RGB4_S3TC 0x83A1 +#define GL_RGBA_S3TC 0x83A2 +#define GL_RGBA4_S3TC 0x83A3 +#define GL_RGBA_DXT5_S3TC 0x83A4 +#define GL_RGBA4_DXT5_S3TC 0x83A5 + +#define GLEW_S3_s3tc GLEW_GET_VAR(__GLEW_S3_s3tc) + +#endif /* GL_S3_s3tc */ + +/* -------------------------- GL_SGIS_color_range -------------------------- */ + +#ifndef GL_SGIS_color_range +#define GL_SGIS_color_range 1 + +#define GL_EXTENDED_RANGE_SGIS 0x85A5 +#define GL_MIN_RED_SGIS 0x85A6 +#define GL_MAX_RED_SGIS 0x85A7 +#define GL_MIN_GREEN_SGIS 0x85A8 +#define GL_MAX_GREEN_SGIS 0x85A9 +#define GL_MIN_BLUE_SGIS 0x85AA +#define GL_MAX_BLUE_SGIS 0x85AB +#define GL_MIN_ALPHA_SGIS 0x85AC +#define GL_MAX_ALPHA_SGIS 0x85AD + +#define GLEW_SGIS_color_range GLEW_GET_VAR(__GLEW_SGIS_color_range) + +#endif /* GL_SGIS_color_range */ + +/* ------------------------- GL_SGIS_detail_texture ------------------------ */ + +#ifndef GL_SGIS_detail_texture +#define GL_SGIS_detail_texture 1 + +typedef void (GLAPIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat* points); + +#define glDetailTexFuncSGIS GLEW_GET_FUN(__glewDetailTexFuncSGIS) +#define glGetDetailTexFuncSGIS GLEW_GET_FUN(__glewGetDetailTexFuncSGIS) + +#define GLEW_SGIS_detail_texture GLEW_GET_VAR(__GLEW_SGIS_detail_texture) + +#endif /* GL_SGIS_detail_texture */ + +/* -------------------------- GL_SGIS_fog_function ------------------------- */ + +#ifndef GL_SGIS_fog_function +#define GL_SGIS_fog_function 1 + +typedef void (GLAPIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLGETFOGFUNCSGISPROC) (GLfloat* points); + +#define glFogFuncSGIS GLEW_GET_FUN(__glewFogFuncSGIS) +#define glGetFogFuncSGIS GLEW_GET_FUN(__glewGetFogFuncSGIS) + +#define GLEW_SGIS_fog_function GLEW_GET_VAR(__GLEW_SGIS_fog_function) + +#endif /* GL_SGIS_fog_function */ + +/* ------------------------ GL_SGIS_generate_mipmap ------------------------ */ + +#ifndef GL_SGIS_generate_mipmap +#define GL_SGIS_generate_mipmap 1 + +#define GL_GENERATE_MIPMAP_SGIS 0x8191 +#define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192 + +#define GLEW_SGIS_generate_mipmap GLEW_GET_VAR(__GLEW_SGIS_generate_mipmap) + +#endif /* GL_SGIS_generate_mipmap */ + +/* -------------------------- GL_SGIS_multisample -------------------------- */ + +#ifndef GL_SGIS_multisample +#define GL_SGIS_multisample 1 + +#define GL_MULTISAMPLE_SGIS 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F +#define GL_SAMPLE_MASK_SGIS 0x80A0 +#define GL_1PASS_SGIS 0x80A1 +#define GL_2PASS_0_SGIS 0x80A2 +#define GL_2PASS_1_SGIS 0x80A3 +#define GL_4PASS_0_SGIS 0x80A4 +#define GL_4PASS_1_SGIS 0x80A5 +#define GL_4PASS_2_SGIS 0x80A6 +#define GL_4PASS_3_SGIS 0x80A7 +#define GL_SAMPLE_BUFFERS_SGIS 0x80A8 +#define GL_SAMPLES_SGIS 0x80A9 +#define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA +#define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB +#define GL_SAMPLE_PATTERN_SGIS 0x80AC +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); + +#define glSampleMaskSGIS GLEW_GET_FUN(__glewSampleMaskSGIS) +#define glSamplePatternSGIS GLEW_GET_FUN(__glewSamplePatternSGIS) + +#define GLEW_SGIS_multisample GLEW_GET_VAR(__GLEW_SGIS_multisample) + +#endif /* GL_SGIS_multisample */ + +/* ------------------------- GL_SGIS_pixel_texture ------------------------- */ + +#ifndef GL_SGIS_pixel_texture +#define GL_SGIS_pixel_texture 1 + +#define GLEW_SGIS_pixel_texture GLEW_GET_VAR(__GLEW_SGIS_pixel_texture) + +#endif /* GL_SGIS_pixel_texture */ + +/* ----------------------- GL_SGIS_point_line_texgen ----------------------- */ + +#ifndef GL_SGIS_point_line_texgen +#define GL_SGIS_point_line_texgen 1 + +#define GL_EYE_DISTANCE_TO_POINT_SGIS 0x81F0 +#define GL_OBJECT_DISTANCE_TO_POINT_SGIS 0x81F1 +#define GL_EYE_DISTANCE_TO_LINE_SGIS 0x81F2 +#define GL_OBJECT_DISTANCE_TO_LINE_SGIS 0x81F3 +#define GL_EYE_POINT_SGIS 0x81F4 +#define GL_OBJECT_POINT_SGIS 0x81F5 +#define GL_EYE_LINE_SGIS 0x81F6 +#define GL_OBJECT_LINE_SGIS 0x81F7 + +#define GLEW_SGIS_point_line_texgen GLEW_GET_VAR(__GLEW_SGIS_point_line_texgen) + +#endif /* GL_SGIS_point_line_texgen */ + +/* ------------------------ GL_SGIS_sharpen_texture ------------------------ */ + +#ifndef GL_SGIS_sharpen_texture +#define GL_SGIS_sharpen_texture 1 + +typedef void (GLAPIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat* points); +typedef void (GLAPIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); + +#define glGetSharpenTexFuncSGIS GLEW_GET_FUN(__glewGetSharpenTexFuncSGIS) +#define glSharpenTexFuncSGIS GLEW_GET_FUN(__glewSharpenTexFuncSGIS) + +#define GLEW_SGIS_sharpen_texture GLEW_GET_VAR(__GLEW_SGIS_sharpen_texture) + +#endif /* GL_SGIS_sharpen_texture */ + +/* --------------------------- GL_SGIS_texture4D --------------------------- */ + +#ifndef GL_SGIS_texture4D +#define GL_SGIS_texture4D 1 + +typedef void (GLAPIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const void* pixels); + +#define glTexImage4DSGIS GLEW_GET_FUN(__glewTexImage4DSGIS) +#define glTexSubImage4DSGIS GLEW_GET_FUN(__glewTexSubImage4DSGIS) + +#define GLEW_SGIS_texture4D GLEW_GET_VAR(__GLEW_SGIS_texture4D) + +#endif /* GL_SGIS_texture4D */ + +/* ---------------------- GL_SGIS_texture_border_clamp --------------------- */ + +#ifndef GL_SGIS_texture_border_clamp +#define GL_SGIS_texture_border_clamp 1 + +#define GL_CLAMP_TO_BORDER_SGIS 0x812D + +#define GLEW_SGIS_texture_border_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_border_clamp) + +#endif /* GL_SGIS_texture_border_clamp */ + +/* ----------------------- GL_SGIS_texture_edge_clamp ---------------------- */ + +#ifndef GL_SGIS_texture_edge_clamp +#define GL_SGIS_texture_edge_clamp 1 + +#define GL_CLAMP_TO_EDGE_SGIS 0x812F + +#define GLEW_SGIS_texture_edge_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_edge_clamp) + +#endif /* GL_SGIS_texture_edge_clamp */ + +/* ------------------------ GL_SGIS_texture_filter4 ------------------------ */ + +#ifndef GL_SGIS_texture_filter4 +#define GL_SGIS_texture_filter4 1 + +typedef void (GLAPIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat* weights); +typedef void (GLAPIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat* weights); + +#define glGetTexFilterFuncSGIS GLEW_GET_FUN(__glewGetTexFilterFuncSGIS) +#define glTexFilterFuncSGIS GLEW_GET_FUN(__glewTexFilterFuncSGIS) + +#define GLEW_SGIS_texture_filter4 GLEW_GET_VAR(__GLEW_SGIS_texture_filter4) + +#endif /* GL_SGIS_texture_filter4 */ + +/* -------------------------- GL_SGIS_texture_lod -------------------------- */ + +#ifndef GL_SGIS_texture_lod +#define GL_SGIS_texture_lod 1 + +#define GL_TEXTURE_MIN_LOD_SGIS 0x813A +#define GL_TEXTURE_MAX_LOD_SGIS 0x813B +#define GL_TEXTURE_BASE_LEVEL_SGIS 0x813C +#define GL_TEXTURE_MAX_LEVEL_SGIS 0x813D + +#define GLEW_SGIS_texture_lod GLEW_GET_VAR(__GLEW_SGIS_texture_lod) + +#endif /* GL_SGIS_texture_lod */ + +/* ------------------------- GL_SGIS_texture_select ------------------------ */ + +#ifndef GL_SGIS_texture_select +#define GL_SGIS_texture_select 1 + +#define GLEW_SGIS_texture_select GLEW_GET_VAR(__GLEW_SGIS_texture_select) + +#endif /* GL_SGIS_texture_select */ + +/* ----------------------------- GL_SGIX_async ----------------------------- */ + +#ifndef GL_SGIX_async +#define GL_SGIX_async 1 + +#define GL_ASYNC_MARKER_SGIX 0x8329 + +typedef void (GLAPIENTRY * PFNGLASYNCMARKERSGIXPROC) (GLuint marker); +typedef void (GLAPIENTRY * PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range); +typedef GLint (GLAPIENTRY * PFNGLFINISHASYNCSGIXPROC) (GLuint* markerp); +typedef GLuint (GLAPIENTRY * PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range); +typedef GLboolean (GLAPIENTRY * PFNGLISASYNCMARKERSGIXPROC) (GLuint marker); +typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); + +#define glAsyncMarkerSGIX GLEW_GET_FUN(__glewAsyncMarkerSGIX) +#define glDeleteAsyncMarkersSGIX GLEW_GET_FUN(__glewDeleteAsyncMarkersSGIX) +#define glFinishAsyncSGIX GLEW_GET_FUN(__glewFinishAsyncSGIX) +#define glGenAsyncMarkersSGIX GLEW_GET_FUN(__glewGenAsyncMarkersSGIX) +#define glIsAsyncMarkerSGIX GLEW_GET_FUN(__glewIsAsyncMarkerSGIX) +#define glPollAsyncSGIX GLEW_GET_FUN(__glewPollAsyncSGIX) + +#define GLEW_SGIX_async GLEW_GET_VAR(__GLEW_SGIX_async) + +#endif /* GL_SGIX_async */ + +/* ------------------------ GL_SGIX_async_histogram ------------------------ */ + +#ifndef GL_SGIX_async_histogram +#define GL_SGIX_async_histogram 1 + +#define GL_ASYNC_HISTOGRAM_SGIX 0x832C +#define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D + +#define GLEW_SGIX_async_histogram GLEW_GET_VAR(__GLEW_SGIX_async_histogram) + +#endif /* GL_SGIX_async_histogram */ + +/* -------------------------- GL_SGIX_async_pixel -------------------------- */ + +#ifndef GL_SGIX_async_pixel +#define GL_SGIX_async_pixel 1 + +#define GL_ASYNC_TEX_IMAGE_SGIX 0x835C +#define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D +#define GL_ASYNC_READ_PIXELS_SGIX 0x835E +#define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F +#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360 +#define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361 + +#define GLEW_SGIX_async_pixel GLEW_GET_VAR(__GLEW_SGIX_async_pixel) + +#endif /* GL_SGIX_async_pixel */ + +/* ----------------------- GL_SGIX_blend_alpha_minmax ---------------------- */ + +#ifndef GL_SGIX_blend_alpha_minmax +#define GL_SGIX_blend_alpha_minmax 1 + +#define GL_ALPHA_MIN_SGIX 0x8320 +#define GL_ALPHA_MAX_SGIX 0x8321 + +#define GLEW_SGIX_blend_alpha_minmax GLEW_GET_VAR(__GLEW_SGIX_blend_alpha_minmax) + +#endif /* GL_SGIX_blend_alpha_minmax */ + +/* ---------------------------- GL_SGIX_clipmap ---------------------------- */ + +#ifndef GL_SGIX_clipmap +#define GL_SGIX_clipmap 1 + +#define GLEW_SGIX_clipmap GLEW_GET_VAR(__GLEW_SGIX_clipmap) + +#endif /* GL_SGIX_clipmap */ + +/* ---------------------- GL_SGIX_convolution_accuracy --------------------- */ + +#ifndef GL_SGIX_convolution_accuracy +#define GL_SGIX_convolution_accuracy 1 + +#define GL_CONVOLUTION_HINT_SGIX 0x8316 + +#define GLEW_SGIX_convolution_accuracy GLEW_GET_VAR(__GLEW_SGIX_convolution_accuracy) + +#endif /* GL_SGIX_convolution_accuracy */ + +/* ------------------------- GL_SGIX_depth_texture ------------------------- */ + +#ifndef GL_SGIX_depth_texture +#define GL_SGIX_depth_texture 1 + +#define GL_DEPTH_COMPONENT16_SGIX 0x81A5 +#define GL_DEPTH_COMPONENT24_SGIX 0x81A6 +#define GL_DEPTH_COMPONENT32_SGIX 0x81A7 + +#define GLEW_SGIX_depth_texture GLEW_GET_VAR(__GLEW_SGIX_depth_texture) + +#endif /* GL_SGIX_depth_texture */ + +/* -------------------------- GL_SGIX_flush_raster ------------------------- */ + +#ifndef GL_SGIX_flush_raster +#define GL_SGIX_flush_raster 1 + +typedef void (GLAPIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void); + +#define glFlushRasterSGIX GLEW_GET_FUN(__glewFlushRasterSGIX) + +#define GLEW_SGIX_flush_raster GLEW_GET_VAR(__GLEW_SGIX_flush_raster) + +#endif /* GL_SGIX_flush_raster */ + +/* --------------------------- GL_SGIX_fog_offset -------------------------- */ + +#ifndef GL_SGIX_fog_offset +#define GL_SGIX_fog_offset 1 + +#define GL_FOG_OFFSET_SGIX 0x8198 +#define GL_FOG_OFFSET_VALUE_SGIX 0x8199 + +#define GLEW_SGIX_fog_offset GLEW_GET_VAR(__GLEW_SGIX_fog_offset) + +#endif /* GL_SGIX_fog_offset */ + +/* -------------------------- GL_SGIX_fog_texture -------------------------- */ + +#ifndef GL_SGIX_fog_texture +#define GL_SGIX_fog_texture 1 + +#define GL_TEXTURE_FOG_SGIX 0 +#define GL_FOG_PATCHY_FACTOR_SGIX 0 +#define GL_FRAGMENT_FOG_SGIX 0 + +typedef void (GLAPIENTRY * PFNGLTEXTUREFOGSGIXPROC) (GLenum pname); + +#define glTextureFogSGIX GLEW_GET_FUN(__glewTextureFogSGIX) + +#define GLEW_SGIX_fog_texture GLEW_GET_VAR(__GLEW_SGIX_fog_texture) + +#endif /* GL_SGIX_fog_texture */ + +/* ------------------- GL_SGIX_fragment_specular_lighting ------------------ */ + +#ifndef GL_SGIX_fragment_specular_lighting +#define GL_SGIX_fragment_specular_lighting 1 + +typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum value, GLfloat* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum value, GLint* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* data); + +#define glFragmentColorMaterialSGIX GLEW_GET_FUN(__glewFragmentColorMaterialSGIX) +#define glFragmentLightModelfSGIX GLEW_GET_FUN(__glewFragmentLightModelfSGIX) +#define glFragmentLightModelfvSGIX GLEW_GET_FUN(__glewFragmentLightModelfvSGIX) +#define glFragmentLightModeliSGIX GLEW_GET_FUN(__glewFragmentLightModeliSGIX) +#define glFragmentLightModelivSGIX GLEW_GET_FUN(__glewFragmentLightModelivSGIX) +#define glFragmentLightfSGIX GLEW_GET_FUN(__glewFragmentLightfSGIX) +#define glFragmentLightfvSGIX GLEW_GET_FUN(__glewFragmentLightfvSGIX) +#define glFragmentLightiSGIX GLEW_GET_FUN(__glewFragmentLightiSGIX) +#define glFragmentLightivSGIX GLEW_GET_FUN(__glewFragmentLightivSGIX) +#define glFragmentMaterialfSGIX GLEW_GET_FUN(__glewFragmentMaterialfSGIX) +#define glFragmentMaterialfvSGIX GLEW_GET_FUN(__glewFragmentMaterialfvSGIX) +#define glFragmentMaterialiSGIX GLEW_GET_FUN(__glewFragmentMaterialiSGIX) +#define glFragmentMaterialivSGIX GLEW_GET_FUN(__glewFragmentMaterialivSGIX) +#define glGetFragmentLightfvSGIX GLEW_GET_FUN(__glewGetFragmentLightfvSGIX) +#define glGetFragmentLightivSGIX GLEW_GET_FUN(__glewGetFragmentLightivSGIX) +#define glGetFragmentMaterialfvSGIX GLEW_GET_FUN(__glewGetFragmentMaterialfvSGIX) +#define glGetFragmentMaterialivSGIX GLEW_GET_FUN(__glewGetFragmentMaterialivSGIX) + +#define GLEW_SGIX_fragment_specular_lighting GLEW_GET_VAR(__GLEW_SGIX_fragment_specular_lighting) + +#endif /* GL_SGIX_fragment_specular_lighting */ + +/* --------------------------- GL_SGIX_framezoom --------------------------- */ + +#ifndef GL_SGIX_framezoom +#define GL_SGIX_framezoom 1 + +typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); + +#define glFrameZoomSGIX GLEW_GET_FUN(__glewFrameZoomSGIX) + +#define GLEW_SGIX_framezoom GLEW_GET_VAR(__GLEW_SGIX_framezoom) + +#endif /* GL_SGIX_framezoom */ + +/* --------------------------- GL_SGIX_interlace --------------------------- */ + +#ifndef GL_SGIX_interlace +#define GL_SGIX_interlace 1 + +#define GL_INTERLACE_SGIX 0x8094 + +#define GLEW_SGIX_interlace GLEW_GET_VAR(__GLEW_SGIX_interlace) + +#endif /* GL_SGIX_interlace */ + +/* ------------------------- GL_SGIX_ir_instrument1 ------------------------ */ + +#ifndef GL_SGIX_ir_instrument1 +#define GL_SGIX_ir_instrument1 1 + +#define GLEW_SGIX_ir_instrument1 GLEW_GET_VAR(__GLEW_SGIX_ir_instrument1) + +#endif /* GL_SGIX_ir_instrument1 */ + +/* ------------------------- GL_SGIX_list_priority ------------------------- */ + +#ifndef GL_SGIX_list_priority +#define GL_SGIX_list_priority 1 + +#define GLEW_SGIX_list_priority GLEW_GET_VAR(__GLEW_SGIX_list_priority) + +#endif /* GL_SGIX_list_priority */ + +/* ------------------------- GL_SGIX_pixel_texture ------------------------- */ + +#ifndef GL_SGIX_pixel_texture +#define GL_SGIX_pixel_texture 1 + +typedef void (GLAPIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); + +#define glPixelTexGenSGIX GLEW_GET_FUN(__glewPixelTexGenSGIX) + +#define GLEW_SGIX_pixel_texture GLEW_GET_VAR(__GLEW_SGIX_pixel_texture) + +#endif /* GL_SGIX_pixel_texture */ + +/* ----------------------- GL_SGIX_pixel_texture_bits ---------------------- */ + +#ifndef GL_SGIX_pixel_texture_bits +#define GL_SGIX_pixel_texture_bits 1 + +#define GLEW_SGIX_pixel_texture_bits GLEW_GET_VAR(__GLEW_SGIX_pixel_texture_bits) + +#endif /* GL_SGIX_pixel_texture_bits */ + +/* ------------------------ GL_SGIX_reference_plane ------------------------ */ + +#ifndef GL_SGIX_reference_plane +#define GL_SGIX_reference_plane 1 + +typedef void (GLAPIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble* equation); + +#define glReferencePlaneSGIX GLEW_GET_FUN(__glewReferencePlaneSGIX) + +#define GLEW_SGIX_reference_plane GLEW_GET_VAR(__GLEW_SGIX_reference_plane) + +#endif /* GL_SGIX_reference_plane */ + +/* ---------------------------- GL_SGIX_resample --------------------------- */ + +#ifndef GL_SGIX_resample +#define GL_SGIX_resample 1 + +#define GL_PACK_RESAMPLE_SGIX 0x842E +#define GL_UNPACK_RESAMPLE_SGIX 0x842F +#define GL_RESAMPLE_DECIMATE_SGIX 0x8430 +#define GL_RESAMPLE_REPLICATE_SGIX 0x8433 +#define GL_RESAMPLE_ZERO_FILL_SGIX 0x8434 + +#define GLEW_SGIX_resample GLEW_GET_VAR(__GLEW_SGIX_resample) + +#endif /* GL_SGIX_resample */ + +/* ----------------------------- GL_SGIX_shadow ---------------------------- */ + +#ifndef GL_SGIX_shadow +#define GL_SGIX_shadow 1 + +#define GL_TEXTURE_COMPARE_SGIX 0x819A +#define GL_TEXTURE_COMPARE_OPERATOR_SGIX 0x819B +#define GL_TEXTURE_LEQUAL_R_SGIX 0x819C +#define GL_TEXTURE_GEQUAL_R_SGIX 0x819D + +#define GLEW_SGIX_shadow GLEW_GET_VAR(__GLEW_SGIX_shadow) + +#endif /* GL_SGIX_shadow */ + +/* ------------------------- GL_SGIX_shadow_ambient ------------------------ */ + +#ifndef GL_SGIX_shadow_ambient +#define GL_SGIX_shadow_ambient 1 + +#define GL_SHADOW_AMBIENT_SGIX 0x80BF + +#define GLEW_SGIX_shadow_ambient GLEW_GET_VAR(__GLEW_SGIX_shadow_ambient) + +#endif /* GL_SGIX_shadow_ambient */ + +/* ----------------------------- GL_SGIX_sprite ---------------------------- */ + +#ifndef GL_SGIX_sprite +#define GL_SGIX_sprite 1 + +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, GLint* params); + +#define glSpriteParameterfSGIX GLEW_GET_FUN(__glewSpriteParameterfSGIX) +#define glSpriteParameterfvSGIX GLEW_GET_FUN(__glewSpriteParameterfvSGIX) +#define glSpriteParameteriSGIX GLEW_GET_FUN(__glewSpriteParameteriSGIX) +#define glSpriteParameterivSGIX GLEW_GET_FUN(__glewSpriteParameterivSGIX) + +#define GLEW_SGIX_sprite GLEW_GET_VAR(__GLEW_SGIX_sprite) + +#endif /* GL_SGIX_sprite */ + +/* ----------------------- GL_SGIX_tag_sample_buffer ----------------------- */ + +#ifndef GL_SGIX_tag_sample_buffer +#define GL_SGIX_tag_sample_buffer 1 + +typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); + +#define glTagSampleBufferSGIX GLEW_GET_FUN(__glewTagSampleBufferSGIX) + +#define GLEW_SGIX_tag_sample_buffer GLEW_GET_VAR(__GLEW_SGIX_tag_sample_buffer) + +#endif /* GL_SGIX_tag_sample_buffer */ + +/* ------------------------ GL_SGIX_texture_add_env ------------------------ */ + +#ifndef GL_SGIX_texture_add_env +#define GL_SGIX_texture_add_env 1 + +#define GLEW_SGIX_texture_add_env GLEW_GET_VAR(__GLEW_SGIX_texture_add_env) + +#endif /* GL_SGIX_texture_add_env */ + +/* -------------------- GL_SGIX_texture_coordinate_clamp ------------------- */ + +#ifndef GL_SGIX_texture_coordinate_clamp +#define GL_SGIX_texture_coordinate_clamp 1 + +#define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369 +#define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A +#define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B + +#define GLEW_SGIX_texture_coordinate_clamp GLEW_GET_VAR(__GLEW_SGIX_texture_coordinate_clamp) + +#endif /* GL_SGIX_texture_coordinate_clamp */ + +/* ------------------------ GL_SGIX_texture_lod_bias ----------------------- */ + +#ifndef GL_SGIX_texture_lod_bias +#define GL_SGIX_texture_lod_bias 1 + +#define GLEW_SGIX_texture_lod_bias GLEW_GET_VAR(__GLEW_SGIX_texture_lod_bias) + +#endif /* GL_SGIX_texture_lod_bias */ + +/* ---------------------- GL_SGIX_texture_multi_buffer --------------------- */ + +#ifndef GL_SGIX_texture_multi_buffer +#define GL_SGIX_texture_multi_buffer 1 + +#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E + +#define GLEW_SGIX_texture_multi_buffer GLEW_GET_VAR(__GLEW_SGIX_texture_multi_buffer) + +#endif /* GL_SGIX_texture_multi_buffer */ + +/* ------------------------- GL_SGIX_texture_range ------------------------- */ + +#ifndef GL_SGIX_texture_range +#define GL_SGIX_texture_range 1 + +#define GL_RGB_SIGNED_SGIX 0x85E0 +#define GL_RGBA_SIGNED_SGIX 0x85E1 +#define GL_ALPHA_SIGNED_SGIX 0x85E2 +#define GL_LUMINANCE_SIGNED_SGIX 0x85E3 +#define GL_INTENSITY_SIGNED_SGIX 0x85E4 +#define GL_LUMINANCE_ALPHA_SIGNED_SGIX 0x85E5 +#define GL_RGB16_SIGNED_SGIX 0x85E6 +#define GL_RGBA16_SIGNED_SGIX 0x85E7 +#define GL_ALPHA16_SIGNED_SGIX 0x85E8 +#define GL_LUMINANCE16_SIGNED_SGIX 0x85E9 +#define GL_INTENSITY16_SIGNED_SGIX 0x85EA +#define GL_LUMINANCE16_ALPHA16_SIGNED_SGIX 0x85EB +#define GL_RGB_EXTENDED_RANGE_SGIX 0x85EC +#define GL_RGBA_EXTENDED_RANGE_SGIX 0x85ED +#define GL_ALPHA_EXTENDED_RANGE_SGIX 0x85EE +#define GL_LUMINANCE_EXTENDED_RANGE_SGIX 0x85EF +#define GL_INTENSITY_EXTENDED_RANGE_SGIX 0x85F0 +#define GL_LUMINANCE_ALPHA_EXTENDED_RANGE_SGIX 0x85F1 +#define GL_RGB16_EXTENDED_RANGE_SGIX 0x85F2 +#define GL_RGBA16_EXTENDED_RANGE_SGIX 0x85F3 +#define GL_ALPHA16_EXTENDED_RANGE_SGIX 0x85F4 +#define GL_LUMINANCE16_EXTENDED_RANGE_SGIX 0x85F5 +#define GL_INTENSITY16_EXTENDED_RANGE_SGIX 0x85F6 +#define GL_LUMINANCE16_ALPHA16_EXTENDED_RANGE_SGIX 0x85F7 +#define GL_MIN_LUMINANCE_SGIS 0x85F8 +#define GL_MAX_LUMINANCE_SGIS 0x85F9 +#define GL_MIN_INTENSITY_SGIS 0x85FA +#define GL_MAX_INTENSITY_SGIS 0x85FB + +#define GLEW_SGIX_texture_range GLEW_GET_VAR(__GLEW_SGIX_texture_range) + +#endif /* GL_SGIX_texture_range */ + +/* ----------------------- GL_SGIX_texture_scale_bias ---------------------- */ + +#ifndef GL_SGIX_texture_scale_bias +#define GL_SGIX_texture_scale_bias 1 + +#define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179 +#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A +#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B +#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C + +#define GLEW_SGIX_texture_scale_bias GLEW_GET_VAR(__GLEW_SGIX_texture_scale_bias) + +#endif /* GL_SGIX_texture_scale_bias */ + +/* ------------------------- GL_SGIX_vertex_preclip ------------------------ */ + +#ifndef GL_SGIX_vertex_preclip +#define GL_SGIX_vertex_preclip 1 + +#define GL_VERTEX_PRECLIP_SGIX 0x83EE +#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF + +#define GLEW_SGIX_vertex_preclip GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip) + +#endif /* GL_SGIX_vertex_preclip */ + +/* ---------------------- GL_SGIX_vertex_preclip_hint ---------------------- */ + +#ifndef GL_SGIX_vertex_preclip_hint +#define GL_SGIX_vertex_preclip_hint 1 + +#define GL_VERTEX_PRECLIP_SGIX 0x83EE +#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF + +#define GLEW_SGIX_vertex_preclip_hint GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip_hint) + +#endif /* GL_SGIX_vertex_preclip_hint */ + +/* ----------------------------- GL_SGIX_ycrcb ----------------------------- */ + +#ifndef GL_SGIX_ycrcb +#define GL_SGIX_ycrcb 1 + +#define GLEW_SGIX_ycrcb GLEW_GET_VAR(__GLEW_SGIX_ycrcb) + +#endif /* GL_SGIX_ycrcb */ + +/* -------------------------- GL_SGI_color_matrix -------------------------- */ + +#ifndef GL_SGI_color_matrix +#define GL_SGI_color_matrix 1 + +#define GL_COLOR_MATRIX_SGI 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB + +#define GLEW_SGI_color_matrix GLEW_GET_VAR(__GLEW_SGI_color_matrix) + +#endif /* GL_SGI_color_matrix */ + +/* --------------------------- GL_SGI_color_table -------------------------- */ + +#ifndef GL_SGI_color_table +#define GL_SGI_color_table 1 + +#define GL_COLOR_TABLE_SGI 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 +#define GL_PROXY_COLOR_TABLE_SGI 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 +#define GL_COLOR_TABLE_SCALE_SGI 0x80D6 +#define GL_COLOR_TABLE_BIAS_SGI 0x80D7 +#define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 +#define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF + +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, void* table); + +#define glColorTableParameterfvSGI GLEW_GET_FUN(__glewColorTableParameterfvSGI) +#define glColorTableParameterivSGI GLEW_GET_FUN(__glewColorTableParameterivSGI) +#define glColorTableSGI GLEW_GET_FUN(__glewColorTableSGI) +#define glCopyColorTableSGI GLEW_GET_FUN(__glewCopyColorTableSGI) +#define glGetColorTableParameterfvSGI GLEW_GET_FUN(__glewGetColorTableParameterfvSGI) +#define glGetColorTableParameterivSGI GLEW_GET_FUN(__glewGetColorTableParameterivSGI) +#define glGetColorTableSGI GLEW_GET_FUN(__glewGetColorTableSGI) + +#define GLEW_SGI_color_table GLEW_GET_VAR(__GLEW_SGI_color_table) + +#endif /* GL_SGI_color_table */ + +/* ----------------------- GL_SGI_texture_color_table ---------------------- */ + +#ifndef GL_SGI_texture_color_table +#define GL_SGI_texture_color_table 1 + +#define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC +#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD + +#define GLEW_SGI_texture_color_table GLEW_GET_VAR(__GLEW_SGI_texture_color_table) + +#endif /* GL_SGI_texture_color_table */ + +/* ------------------------- GL_SUNX_constant_data ------------------------- */ + +#ifndef GL_SUNX_constant_data +#define GL_SUNX_constant_data 1 + +#define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5 +#define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6 + +typedef void (GLAPIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void); + +#define glFinishTextureSUNX GLEW_GET_FUN(__glewFinishTextureSUNX) + +#define GLEW_SUNX_constant_data GLEW_GET_VAR(__GLEW_SUNX_constant_data) + +#endif /* GL_SUNX_constant_data */ + +/* -------------------- GL_SUN_convolution_border_modes -------------------- */ + +#ifndef GL_SUN_convolution_border_modes +#define GL_SUN_convolution_border_modes 1 + +#define GL_WRAP_BORDER_SUN 0x81D4 + +#define GLEW_SUN_convolution_border_modes GLEW_GET_VAR(__GLEW_SUN_convolution_border_modes) + +#endif /* GL_SUN_convolution_border_modes */ + +/* -------------------------- GL_SUN_global_alpha -------------------------- */ + +#ifndef GL_SUN_global_alpha +#define GL_SUN_global_alpha 1 + +#define GL_GLOBAL_ALPHA_SUN 0x81D9 +#define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA + +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor); + +#define glGlobalAlphaFactorbSUN GLEW_GET_FUN(__glewGlobalAlphaFactorbSUN) +#define glGlobalAlphaFactordSUN GLEW_GET_FUN(__glewGlobalAlphaFactordSUN) +#define glGlobalAlphaFactorfSUN GLEW_GET_FUN(__glewGlobalAlphaFactorfSUN) +#define glGlobalAlphaFactoriSUN GLEW_GET_FUN(__glewGlobalAlphaFactoriSUN) +#define glGlobalAlphaFactorsSUN GLEW_GET_FUN(__glewGlobalAlphaFactorsSUN) +#define glGlobalAlphaFactorubSUN GLEW_GET_FUN(__glewGlobalAlphaFactorubSUN) +#define glGlobalAlphaFactoruiSUN GLEW_GET_FUN(__glewGlobalAlphaFactoruiSUN) +#define glGlobalAlphaFactorusSUN GLEW_GET_FUN(__glewGlobalAlphaFactorusSUN) + +#define GLEW_SUN_global_alpha GLEW_GET_VAR(__GLEW_SUN_global_alpha) + +#endif /* GL_SUN_global_alpha */ + +/* --------------------------- GL_SUN_mesh_array --------------------------- */ + +#ifndef GL_SUN_mesh_array +#define GL_SUN_mesh_array 1 + +#define GL_QUAD_MESH_SUN 0x8614 +#define GL_TRIANGLE_MESH_SUN 0x8615 + +#define GLEW_SUN_mesh_array GLEW_GET_VAR(__GLEW_SUN_mesh_array) + +#endif /* GL_SUN_mesh_array */ + +/* ------------------------ GL_SUN_read_video_pixels ----------------------- */ + +#ifndef GL_SUN_read_video_pixels +#define GL_SUN_read_video_pixels 1 + +typedef void (GLAPIENTRY * PFNGLREADVIDEOPIXELSSUNPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); + +#define glReadVideoPixelsSUN GLEW_GET_FUN(__glewReadVideoPixelsSUN) + +#define GLEW_SUN_read_video_pixels GLEW_GET_VAR(__GLEW_SUN_read_video_pixels) + +#endif /* GL_SUN_read_video_pixels */ + +/* --------------------------- GL_SUN_slice_accum -------------------------- */ + +#ifndef GL_SUN_slice_accum +#define GL_SUN_slice_accum 1 + +#define GL_SLICE_ACCUM_SUN 0x85CC + +#define GLEW_SUN_slice_accum GLEW_GET_VAR(__GLEW_SUN_slice_accum) + +#endif /* GL_SUN_slice_accum */ + +/* -------------------------- GL_SUN_triangle_list ------------------------- */ + +#ifndef GL_SUN_triangle_list +#define GL_SUN_triangle_list 1 + +#define GL_RESTART_SUN 0x01 +#define GL_REPLACE_MIDDLE_SUN 0x02 +#define GL_REPLACE_OLDEST_SUN 0x03 +#define GL_TRIANGLE_LIST_SUN 0x81D7 +#define GL_REPLACEMENT_CODE_SUN 0x81D8 +#define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0 +#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1 +#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2 +#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3 +#define GL_R1UI_V3F_SUN 0x85C4 +#define GL_R1UI_C4UB_V3F_SUN 0x85C5 +#define GL_R1UI_C3F_V3F_SUN 0x85C6 +#define GL_R1UI_N3F_V3F_SUN 0x85C7 +#define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8 +#define GL_R1UI_T2F_V3F_SUN 0x85C9 +#define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA +#define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB + +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte* code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint* code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort* code); + +#define glReplacementCodePointerSUN GLEW_GET_FUN(__glewReplacementCodePointerSUN) +#define glReplacementCodeubSUN GLEW_GET_FUN(__glewReplacementCodeubSUN) +#define glReplacementCodeubvSUN GLEW_GET_FUN(__glewReplacementCodeubvSUN) +#define glReplacementCodeuiSUN GLEW_GET_FUN(__glewReplacementCodeuiSUN) +#define glReplacementCodeuivSUN GLEW_GET_FUN(__glewReplacementCodeuivSUN) +#define glReplacementCodeusSUN GLEW_GET_FUN(__glewReplacementCodeusSUN) +#define glReplacementCodeusvSUN GLEW_GET_FUN(__glewReplacementCodeusvSUN) + +#define GLEW_SUN_triangle_list GLEW_GET_VAR(__GLEW_SUN_triangle_list) + +#endif /* GL_SUN_triangle_list */ + +/* ----------------------------- GL_SUN_vertex ----------------------------- */ + +#ifndef GL_SUN_vertex +#define GL_SUN_vertex 1 + +typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint* rc, const GLubyte *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat* tc, const GLubyte *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *v); + +#define glColor3fVertex3fSUN GLEW_GET_FUN(__glewColor3fVertex3fSUN) +#define glColor3fVertex3fvSUN GLEW_GET_FUN(__glewColor3fVertex3fvSUN) +#define glColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fSUN) +#define glColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fvSUN) +#define glColor4ubVertex2fSUN GLEW_GET_FUN(__glewColor4ubVertex2fSUN) +#define glColor4ubVertex2fvSUN GLEW_GET_FUN(__glewColor4ubVertex2fvSUN) +#define glColor4ubVertex3fSUN GLEW_GET_FUN(__glewColor4ubVertex3fSUN) +#define glColor4ubVertex3fvSUN GLEW_GET_FUN(__glewColor4ubVertex3fvSUN) +#define glNormal3fVertex3fSUN GLEW_GET_FUN(__glewNormal3fVertex3fSUN) +#define glNormal3fVertex3fvSUN GLEW_GET_FUN(__glewNormal3fVertex3fvSUN) +#define glReplacementCodeuiColor3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fSUN) +#define glReplacementCodeuiColor3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fvSUN) +#define glReplacementCodeuiColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fSUN) +#define glReplacementCodeuiColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN) +#define glReplacementCodeuiColor4ubVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fSUN) +#define glReplacementCodeuiColor4ubVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fvSUN) +#define glReplacementCodeuiNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fSUN) +#define glReplacementCodeuiNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fvSUN) +#define glReplacementCodeuiVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fSUN) +#define glReplacementCodeuiVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fvSUN) +#define glTexCoord2fColor3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fSUN) +#define glTexCoord2fColor3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fvSUN) +#define glTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fSUN) +#define glTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fvSUN) +#define glTexCoord2fColor4ubVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fSUN) +#define glTexCoord2fColor4ubVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fvSUN) +#define glTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fSUN) +#define glTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fvSUN) +#define glTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fSUN) +#define glTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fvSUN) +#define glTexCoord4fColor4fNormal3fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fSUN) +#define glTexCoord4fColor4fNormal3fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fvSUN) +#define glTexCoord4fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fSUN) +#define glTexCoord4fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fvSUN) + +#define GLEW_SUN_vertex GLEW_GET_VAR(__GLEW_SUN_vertex) + +#endif /* GL_SUN_vertex */ + +/* -------------------------- GL_WIN_phong_shading ------------------------- */ + +#ifndef GL_WIN_phong_shading +#define GL_WIN_phong_shading 1 + +#define GL_PHONG_WIN 0x80EA +#define GL_PHONG_HINT_WIN 0x80EB + +#define GLEW_WIN_phong_shading GLEW_GET_VAR(__GLEW_WIN_phong_shading) + +#endif /* GL_WIN_phong_shading */ + +/* -------------------------- GL_WIN_specular_fog -------------------------- */ + +#ifndef GL_WIN_specular_fog +#define GL_WIN_specular_fog 1 + +#define GL_FOG_SPECULAR_TEXTURE_WIN 0x80EC + +#define GLEW_WIN_specular_fog GLEW_GET_VAR(__GLEW_WIN_specular_fog) + +#endif /* GL_WIN_specular_fog */ + +/* ---------------------------- GL_WIN_swap_hint --------------------------- */ + +#ifndef GL_WIN_swap_hint +#define GL_WIN_swap_hint 1 + +typedef void (GLAPIENTRY * PFNGLADDSWAPHINTRECTWINPROC) (GLint x, GLint y, GLsizei width, GLsizei height); + +#define glAddSwapHintRectWIN GLEW_GET_FUN(__glewAddSwapHintRectWIN) + +#define GLEW_WIN_swap_hint GLEW_GET_VAR(__GLEW_WIN_swap_hint) + +#endif /* GL_WIN_swap_hint */ + +/* ------------------------------------------------------------------------- */ + +#if defined(GLEW_MX) && defined(_WIN32) +#define GLEW_FUN_EXPORT +#else +#define GLEW_FUN_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#if defined(GLEW_MX) +#define GLEW_VAR_EXPORT +#else +#define GLEW_VAR_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#if defined(GLEW_MX) && defined(_WIN32) +struct GLEWContextStruct +{ +#endif /* GLEW_MX */ + +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DPROC __glewTexImage3D; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D; + +GLEW_FUN_EXPORT PFNGLACTIVETEXTUREPROC __glewActiveTexture; +GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv; +GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage; + +GLEW_FUN_EXPORT PFNGLBLENDCOLORPROC __glewBlendColor; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONPROC __glewBlendEquation; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate; +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer; +GLEW_FUN_EXPORT PFNGLFOGCOORDDPROC __glewFogCoordd; +GLEW_FUN_EXPORT PFNGLFOGCOORDDVPROC __glewFogCoorddv; +GLEW_FUN_EXPORT PFNGLFOGCOORDFPROC __glewFogCoordf; +GLEW_FUN_EXPORT PFNGLFOGCOORDFVPROC __glewFogCoordfv; +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFPROC __glewPointParameterf; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIPROC __glewPointParameteri; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DPROC __glewWindowPos2d; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FPROC __glewWindowPos2f; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IPROC __glewWindowPos2i; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SPROC __glewWindowPos2s; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DPROC __glewWindowPos3d; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FPROC __glewWindowPos3f; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IPROC __glewWindowPos3i; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SPROC __glewWindowPos3s; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv; + +GLEW_FUN_EXPORT PFNGLBEGINQUERYPROC __glewBeginQuery; +GLEW_FUN_EXPORT PFNGLBINDBUFFERPROC __glewBindBuffer; +GLEW_FUN_EXPORT PFNGLBUFFERDATAPROC __glewBufferData; +GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAPROC __glewBufferSubData; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERSPROC __glewDeleteBuffers; +GLEW_FUN_EXPORT PFNGLDELETEQUERIESPROC __glewDeleteQueries; +GLEW_FUN_EXPORT PFNGLENDQUERYPROC __glewEndQuery; +GLEW_FUN_EXPORT PFNGLGENBUFFERSPROC __glewGenBuffers; +GLEW_FUN_EXPORT PFNGLGENQUERIESPROC __glewGenQueries; +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv; +GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv; +GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv; +GLEW_FUN_EXPORT PFNGLGETQUERYIVPROC __glewGetQueryiv; +GLEW_FUN_EXPORT PFNGLISBUFFERPROC __glewIsBuffer; +GLEW_FUN_EXPORT PFNGLISQUERYPROC __glewIsQuery; +GLEW_FUN_EXPORT PFNGLMAPBUFFERPROC __glewMapBuffer; +GLEW_FUN_EXPORT PFNGLUNMAPBUFFERPROC __glewUnmapBuffer; + +GLEW_FUN_EXPORT PFNGLATTACHSHADERPROC __glewAttachShader; +GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate; +GLEW_FUN_EXPORT PFNGLCOMPILESHADERPROC __glewCompileShader; +GLEW_FUN_EXPORT PFNGLCREATEPROGRAMPROC __glewCreateProgram; +GLEW_FUN_EXPORT PFNGLCREATESHADERPROC __glewCreateShader; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMPROC __glewDeleteProgram; +GLEW_FUN_EXPORT PFNGLDELETESHADERPROC __glewDeleteShader; +GLEW_FUN_EXPORT PFNGLDETACHSHADERPROC __glewDetachShader; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray; +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSPROC __glewDrawBuffers; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray; +GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform; +GLEW_FUN_EXPORT PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders; +GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation; +GLEW_FUN_EXPORT PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVPROC __glewGetProgramiv; +GLEW_FUN_EXPORT PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog; +GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEPROC __glewGetShaderSource; +GLEW_FUN_EXPORT PFNGLGETSHADERIVPROC __glewGetShaderiv; +GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation; +GLEW_FUN_EXPORT PFNGLGETUNIFORMFVPROC __glewGetUniformfv; +GLEW_FUN_EXPORT PFNGLGETUNIFORMIVPROC __glewGetUniformiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv; +GLEW_FUN_EXPORT PFNGLISPROGRAMPROC __glewIsProgram; +GLEW_FUN_EXPORT PFNGLISSHADERPROC __glewIsShader; +GLEW_FUN_EXPORT PFNGLLINKPROGRAMPROC __glewLinkProgram; +GLEW_FUN_EXPORT PFNGLSHADERSOURCEPROC __glewShaderSource; +GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate; +GLEW_FUN_EXPORT PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate; +GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate; +GLEW_FUN_EXPORT PFNGLUNIFORM1FPROC __glewUniform1f; +GLEW_FUN_EXPORT PFNGLUNIFORM1FVPROC __glewUniform1fv; +GLEW_FUN_EXPORT PFNGLUNIFORM1IPROC __glewUniform1i; +GLEW_FUN_EXPORT PFNGLUNIFORM1IVPROC __glewUniform1iv; +GLEW_FUN_EXPORT PFNGLUNIFORM2FPROC __glewUniform2f; +GLEW_FUN_EXPORT PFNGLUNIFORM2FVPROC __glewUniform2fv; +GLEW_FUN_EXPORT PFNGLUNIFORM2IPROC __glewUniform2i; +GLEW_FUN_EXPORT PFNGLUNIFORM2IVPROC __glewUniform2iv; +GLEW_FUN_EXPORT PFNGLUNIFORM3FPROC __glewUniform3f; +GLEW_FUN_EXPORT PFNGLUNIFORM3FVPROC __glewUniform3fv; +GLEW_FUN_EXPORT PFNGLUNIFORM3IPROC __glewUniform3i; +GLEW_FUN_EXPORT PFNGLUNIFORM3IVPROC __glewUniform3iv; +GLEW_FUN_EXPORT PFNGLUNIFORM4FPROC __glewUniform4f; +GLEW_FUN_EXPORT PFNGLUNIFORM4FVPROC __glewUniform4fv; +GLEW_FUN_EXPORT PFNGLUNIFORM4IPROC __glewUniform4i; +GLEW_FUN_EXPORT PFNGLUNIFORM4IVPROC __glewUniform4iv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv; +GLEW_FUN_EXPORT PFNGLUSEPROGRAMPROC __glewUseProgram; +GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMPROC __glewValidateProgram; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer; + +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv; + +GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender; +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback; +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation; +GLEW_FUN_EXPORT PFNGLCLAMPCOLORPROC __glewClampColor; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERFIPROC __glewClearBufferfi; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERFVPROC __glewClearBufferfv; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERIVPROC __glewClearBufferiv; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv; +GLEW_FUN_EXPORT PFNGLCOLORMASKIPROC __glewColorMaski; +GLEW_FUN_EXPORT PFNGLDISABLEIPROC __glewDisablei; +GLEW_FUN_EXPORT PFNGLENABLEIPROC __glewEnablei; +GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback; +GLEW_FUN_EXPORT PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v; +GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation; +GLEW_FUN_EXPORT PFNGLGETSTRINGIPROC __glewGetStringi; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying; +GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv; +GLEW_FUN_EXPORT PFNGLISENABLEDIPROC __glewIsEnabledi; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIPROC __glewUniform1ui; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIVPROC __glewUniform1uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIPROC __glewUniform2ui; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIVPROC __glewUniform2uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIPROC __glewUniform3ui; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIVPROC __glewUniform3uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIPROC __glewUniform4ui; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIVPROC __glewUniform4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced; +GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex; +GLEW_FUN_EXPORT PFNGLTEXBUFFERPROC __glewTexBuffer; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture; +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v; +GLEW_FUN_EXPORT PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v; + +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIPROC __glewBlendEquationi; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei; +GLEW_FUN_EXPORT PFNGLBLENDFUNCIPROC __glewBlendFunci; +GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading; + +GLEW_FUN_EXPORT PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX; + +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD; +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD; +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD; +GLEW_FUN_EXPORT PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD; +GLEW_FUN_EXPORT PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD; + +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD; + +GLEW_FUN_EXPORT PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD; +GLEW_FUN_EXPORT PFNGLGENNAMESAMDPROC __glewGenNamesAMD; +GLEW_FUN_EXPORT PFNGLISNAMEAMDPROC __glewIsNameAMD; + +GLEW_FUN_EXPORT PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD; +GLEW_FUN_EXPORT PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD; +GLEW_FUN_EXPORT PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD; +GLEW_FUN_EXPORT PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD; +GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD; +GLEW_FUN_EXPORT PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD; + +GLEW_FUN_EXPORT PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD; + +GLEW_FUN_EXPORT PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD; +GLEW_FUN_EXPORT PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE; + +GLEW_FUN_EXPORT PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE; +GLEW_FUN_EXPORT PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE; +GLEW_FUN_EXPORT PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE; +GLEW_FUN_EXPORT PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE; +GLEW_FUN_EXPORT PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE; +GLEW_FUN_EXPORT PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE; +GLEW_FUN_EXPORT PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE; +GLEW_FUN_EXPORT PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE; + +GLEW_FUN_EXPORT PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE; +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE; +GLEW_FUN_EXPORT PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE; +GLEW_FUN_EXPORT PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE; + +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE; +GLEW_FUN_EXPORT PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE; + +GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE; +GLEW_FUN_EXPORT PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE; +GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE; +GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE; +GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE; +GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHFPROC __glewClearDepthf; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEFPROC __glewDepthRangef; +GLEW_FUN_EXPORT PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat; +GLEW_FUN_EXPORT PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler; +GLEW_FUN_EXPORT PFNGLSHADERBINARYPROC __glewShaderBinary; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance; + +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed; +GLEW_FUN_EXPORT PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex; + +GLEW_FUN_EXPORT PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB; + +GLEW_FUN_EXPORT PFNGLCLAMPCOLORARBPROC __glewClampColorARB; + +GLEW_FUN_EXPORT PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData; + +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB; +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB; +GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB; +GLEW_FUN_EXPORT PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB; +GLEW_FUN_EXPORT PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect; + +GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer; +GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer; +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer; +GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus; +GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers; +GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer; +GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers; +GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers; +GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv; +GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv; +GLEW_FUN_EXPORT PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer; +GLEW_FUN_EXPORT PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB; + +GLEW_FUN_EXPORT PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary; +GLEW_FUN_EXPORT PFNGLPROGRAMBINARYPROC __glewProgramBinary; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri; + +GLEW_FUN_EXPORT PFNGLGETUNIFORMDVPROC __glewGetUniformdv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DEXTPROC __glewProgramUniform1dEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DVEXTPROC __glewProgramUniform1dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DEXTPROC __glewProgramUniform2dEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DVEXTPROC __glewProgramUniform2dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DEXTPROC __glewProgramUniform3dEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DVEXTPROC __glewProgramUniform3dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DEXTPROC __glewProgramUniform4dEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DVEXTPROC __glewProgramUniform4dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC __glewProgramUniformMatrix2dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC __glewProgramUniformMatrix2x3dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC __glewProgramUniformMatrix2x4dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC __glewProgramUniformMatrix3dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC __glewProgramUniformMatrix3x2dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC __glewProgramUniformMatrix3x4dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC __glewProgramUniformMatrix4dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC __glewProgramUniformMatrix4x2dvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC __glewProgramUniformMatrix4x3dvEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM1DPROC __glewUniform1d; +GLEW_FUN_EXPORT PFNGLUNIFORM1DVPROC __glewUniform1dv; +GLEW_FUN_EXPORT PFNGLUNIFORM2DPROC __glewUniform2d; +GLEW_FUN_EXPORT PFNGLUNIFORM2DVPROC __glewUniform2dv; +GLEW_FUN_EXPORT PFNGLUNIFORM3DPROC __glewUniform3d; +GLEW_FUN_EXPORT PFNGLUNIFORM3DVPROC __glewUniform3dv; +GLEW_FUN_EXPORT PFNGLUNIFORM4DPROC __glewUniform4d; +GLEW_FUN_EXPORT PFNGLUNIFORM4DVPROC __glewUniform4dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv; + +GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEPROC __glewColorSubTable; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPROC __glewColorTable; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv; +GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable; +GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPROC __glewGetColorTable; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPROC __glewGetHistogram; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv; +GLEW_FUN_EXPORT PFNGLGETMINMAXPROC __glewGetMinmax; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv; +GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter; +GLEW_FUN_EXPORT PFNGLHISTOGRAMPROC __glewHistogram; +GLEW_FUN_EXPORT PFNGLMINMAXPROC __glewMinmax; +GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMPROC __glewResetHistogram; +GLEW_FUN_EXPORT PFNGLRESETMINMAXPROC __glewResetMinmax; +GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB; + +GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ; + +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange; +GLEW_FUN_EXPORT PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange; + +GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB; + +GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB; + +GLEW_FUN_EXPORT PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB; +GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB; + +GLEW_FUN_EXPORT PFNGLBEGINQUERYARBPROC __glewBeginQueryARB; +GLEW_FUN_EXPORT PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB; +GLEW_FUN_EXPORT PFNGLENDQUERYARBPROC __glewEndQueryARB; +GLEW_FUN_EXPORT PFNGLGENQUERIESARBPROC __glewGenQueriesARB; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB; +GLEW_FUN_EXPORT PFNGLGETQUERYIVARBPROC __glewGetQueryivARB; +GLEW_FUN_EXPORT PFNGLISQUERYARBPROC __glewIsQueryARB; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB; + +GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex; + +GLEW_FUN_EXPORT PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB; +GLEW_FUN_EXPORT PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB; +GLEW_FUN_EXPORT PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB; +GLEW_FUN_EXPORT PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB; +GLEW_FUN_EXPORT PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB; +GLEW_FUN_EXPORT PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB; +GLEW_FUN_EXPORT PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB; +GLEW_FUN_EXPORT PFNGLGETNMAPIVARBPROC __glewGetnMapivARB; +GLEW_FUN_EXPORT PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB; +GLEW_FUN_EXPORT PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB; +GLEW_FUN_EXPORT PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB; +GLEW_FUN_EXPORT PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB; +GLEW_FUN_EXPORT PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB; +GLEW_FUN_EXPORT PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB; +GLEW_FUN_EXPORT PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB; +GLEW_FUN_EXPORT PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB; + +GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB; + +GLEW_FUN_EXPORT PFNGLBINDSAMPLERPROC __glewBindSampler; +GLEW_FUN_EXPORT PFNGLDELETESAMPLERSPROC __glewDeleteSamplers; +GLEW_FUN_EXPORT PFNGLGENSAMPLERSPROC __glewGenSamplers; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv; +GLEW_FUN_EXPORT PFNGLISSAMPLERPROC __glewIsSampler; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv; + +GLEW_FUN_EXPORT PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram; +GLEW_FUN_EXPORT PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline; +GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines; +GLEW_FUN_EXPORT PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv; +GLEW_FUN_EXPORT PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv; +GLEW_FUN_EXPORT PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages; +GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline; + +GLEW_FUN_EXPORT PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv; + +GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture; +GLEW_FUN_EXPORT PFNGLMEMORYBARRIERPROC __glewMemoryBarrier; + +GLEW_FUN_EXPORT PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB; +GLEW_FUN_EXPORT PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB; +GLEW_FUN_EXPORT PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB; +GLEW_FUN_EXPORT PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB; +GLEW_FUN_EXPORT PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB; +GLEW_FUN_EXPORT PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB; +GLEW_FUN_EXPORT PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB; +GLEW_FUN_EXPORT PFNGLGETHANDLEARBPROC __glewGetHandleARB; +GLEW_FUN_EXPORT PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB; +GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB; +GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB; +GLEW_FUN_EXPORT PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB; +GLEW_FUN_EXPORT PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1FARBPROC __glewUniform1fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1IARBPROC __glewUniform1iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2FARBPROC __glewUniform2fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2IARBPROC __glewUniform2iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3FARBPROC __glewUniform3fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3IARBPROC __glewUniform3iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4FARBPROC __glewUniform4fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4IARBPROC __glewUniform4iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB; +GLEW_FUN_EXPORT PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB; +GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB; + +GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName; +GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName; +GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv; +GLEW_FUN_EXPORT PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv; +GLEW_FUN_EXPORT PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex; +GLEW_FUN_EXPORT PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation; +GLEW_FUN_EXPORT PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv; +GLEW_FUN_EXPORT PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv; + +GLEW_FUN_EXPORT PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB; +GLEW_FUN_EXPORT PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB; +GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB; +GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB; +GLEW_FUN_EXPORT PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB; +GLEW_FUN_EXPORT PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB; + +GLEW_FUN_EXPORT PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync; +GLEW_FUN_EXPORT PFNGLDELETESYNCPROC __glewDeleteSync; +GLEW_FUN_EXPORT PFNGLFENCESYNCPROC __glewFenceSync; +GLEW_FUN_EXPORT PFNGLGETINTEGER64VPROC __glewGetInteger64v; +GLEW_FUN_EXPORT PFNGLGETSYNCIVPROC __glewGetSynciv; +GLEW_FUN_EXPORT PFNGLISSYNCPROC __glewIsSync; +GLEW_FUN_EXPORT PFNGLWAITSYNCPROC __glewWaitSync; + +GLEW_FUN_EXPORT PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv; +GLEW_FUN_EXPORT PFNGLPATCHPARAMETERIPROC __glewPatchParameteri; + +GLEW_FUN_EXPORT PFNGLTEXBUFFERARBPROC __glewTexBufferARB; + +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB; + +GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv; +GLEW_FUN_EXPORT PFNGLSAMPLEMASKIPROC __glewSampleMaski; +GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample; + +GLEW_FUN_EXPORT PFNGLTEXSTORAGE1DPROC __glewTexStorage1D; +GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DPROC __glewTexStorage2D; +GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DPROC __glewTexStorage3D; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT; + +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v; +GLEW_FUN_EXPORT PFNGLQUERYCOUNTERPROC __glewQueryCounter; + +GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback; +GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback; +GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks; +GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback; +GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback; +GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback; + +GLEW_FUN_EXPORT PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream; +GLEW_FUN_EXPORT PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed; +GLEW_FUN_EXPORT PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv; + +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced; + +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB; + +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEPROC __glewBindBufferBase; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv; +GLEW_FUN_EXPORT PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v; +GLEW_FUN_EXPORT PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex; +GLEW_FUN_EXPORT PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices; +GLEW_FUN_EXPORT PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding; + +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYPROC __glewIsVertexArray; + +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer; + +GLEW_FUN_EXPORT PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB; +GLEW_FUN_EXPORT PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB; +GLEW_FUN_EXPORT PFNGLWEIGHTBVARBPROC __glewWeightbvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTDVARBPROC __glewWeightdvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTFVARBPROC __glewWeightfvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTIVARBPROC __glewWeightivARB; +GLEW_FUN_EXPORT PFNGLWEIGHTSVARBPROC __glewWeightsvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUBVARBPROC __glewWeightubvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUIVARBPROC __glewWeightuivARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUSVARBPROC __glewWeightusvARB; + +GLEW_FUN_EXPORT PFNGLBINDBUFFERARBPROC __glewBindBufferARB; +GLEW_FUN_EXPORT PFNGLBUFFERDATAARBPROC __glewBufferDataARB; +GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB; +GLEW_FUN_EXPORT PFNGLGENBUFFERSARBPROC __glewGenBuffersARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB; +GLEW_FUN_EXPORT PFNGLISBUFFERARBPROC __glewIsBufferARB; +GLEW_FUN_EXPORT PFNGLMAPBUFFERARBPROC __glewMapBufferARB; +GLEW_FUN_EXPORT PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB; + +GLEW_FUN_EXPORT PFNGLBINDPROGRAMARBPROC __glewBindProgramARB; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB; +GLEW_FUN_EXPORT PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB; +GLEW_FUN_EXPORT PFNGLISPROGRAMARBPROC __glewIsProgramARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB; + +GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB; +GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB; +GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB; + +GLEW_FUN_EXPORT PFNGLCOLORP3UIPROC __glewColorP3ui; +GLEW_FUN_EXPORT PFNGLCOLORP3UIVPROC __glewColorP3uiv; +GLEW_FUN_EXPORT PFNGLCOLORP4UIPROC __glewColorP4ui; +GLEW_FUN_EXPORT PFNGLCOLORP4UIVPROC __glewColorP4uiv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv; +GLEW_FUN_EXPORT PFNGLNORMALP3UIPROC __glewNormalP3ui; +GLEW_FUN_EXPORT PFNGLNORMALP3UIVPROC __glewNormalP3uiv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv; +GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui; +GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv; +GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui; +GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv; +GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui; +GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv; +GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui; +GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXP2UIPROC __glewVertexP2ui; +GLEW_FUN_EXPORT PFNGLVERTEXP2UIVPROC __glewVertexP2uiv; +GLEW_FUN_EXPORT PFNGLVERTEXP3UIPROC __glewVertexP3ui; +GLEW_FUN_EXPORT PFNGLVERTEXP3UIVPROC __glewVertexP3uiv; +GLEW_FUN_EXPORT PFNGLVERTEXP4UIPROC __glewVertexP4ui; +GLEW_FUN_EXPORT PFNGLVERTEXP4UIVPROC __glewVertexP4uiv; + +GLEW_FUN_EXPORT PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed; +GLEW_FUN_EXPORT PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v; +GLEW_FUN_EXPORT PFNGLGETFLOATI_VPROC __glewGetFloati_v; +GLEW_FUN_EXPORT PFNGLSCISSORARRAYVPROC __glewScissorArrayv; +GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDPROC __glewScissorIndexed; +GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv; +GLEW_FUN_EXPORT PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv; +GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf; +GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv; + +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI; +GLEW_FUN_EXPORT PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI; + +GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI; +GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI; +GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI; +GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI; + +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI; +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI; +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI; +GLEW_FUN_EXPORT PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI; +GLEW_FUN_EXPORT PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI; +GLEW_FUN_EXPORT PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI; +GLEW_FUN_EXPORT PFNGLSAMPLEMAPATIPROC __glewSampleMapATI; +GLEW_FUN_EXPORT PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI; + +GLEW_FUN_EXPORT PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI; +GLEW_FUN_EXPORT PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI; + +GLEW_FUN_EXPORT PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI; +GLEW_FUN_EXPORT PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI; + +GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI; +GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI; + +GLEW_FUN_EXPORT PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI; +GLEW_FUN_EXPORT PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI; +GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI; +GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI; +GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI; +GLEW_FUN_EXPORT PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI; +GLEW_FUN_EXPORT PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI; +GLEW_FUN_EXPORT PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI; + +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI; + +GLEW_FUN_EXPORT PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI; +GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI; +GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI; + +GLEW_FUN_EXPORT PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT; +GLEW_FUN_EXPORT PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT; +GLEW_FUN_EXPORT PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT; + +GLEW_FUN_EXPORT PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT; + +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT; + +GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT; +GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT; + +GLEW_FUN_EXPORT PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT; +GLEW_FUN_EXPORT PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT; + +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT; +GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT; + +GLEW_FUN_EXPORT PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT; +GLEW_FUN_EXPORT PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT; + +GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT; + +GLEW_FUN_EXPORT PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT; +GLEW_FUN_EXPORT PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT; + +GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT; + +GLEW_FUN_EXPORT PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT; +GLEW_FUN_EXPORT PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT; +GLEW_FUN_EXPORT PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT; +GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT; +GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT; +GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT; +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT; +GLEW_FUN_EXPORT PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT; +GLEW_FUN_EXPORT PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT; +GLEW_FUN_EXPORT PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT; +GLEW_FUN_EXPORT PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT; +GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT; +GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT; +GLEW_FUN_EXPORT PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT; +GLEW_FUN_EXPORT PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT; +GLEW_FUN_EXPORT PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT; +GLEW_FUN_EXPORT PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT; +GLEW_FUN_EXPORT PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT; +GLEW_FUN_EXPORT PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT; +GLEW_FUN_EXPORT PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT; +GLEW_FUN_EXPORT PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT; +GLEW_FUN_EXPORT PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT; + +GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT; +GLEW_FUN_EXPORT PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT; +GLEW_FUN_EXPORT PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT; +GLEW_FUN_EXPORT PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT; +GLEW_FUN_EXPORT PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT; + +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT; + +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT; + +GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT; +GLEW_FUN_EXPORT PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT; + +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT; + +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT; + +GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT; +GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT; +GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT; +GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT; +GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT; +GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT; +GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT; +GLEW_FUN_EXPORT PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT; + +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT; + +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT; +GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT; + +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT; +GLEW_FUN_EXPORT PFNGLHISTOGRAMEXTPROC __glewHistogramEXT; +GLEW_FUN_EXPORT PFNGLMINMAXEXTPROC __glewMinmaxEXT; +GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT; +GLEW_FUN_EXPORT PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT; + +GLEW_FUN_EXPORT PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT; + +GLEW_FUN_EXPORT PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT; + +GLEW_FUN_EXPORT PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT; +GLEW_FUN_EXPORT PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT; + +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT; + +GLEW_FUN_EXPORT PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT; +GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT; + +GLEW_FUN_EXPORT PFNGLCOLORTABLEEXTPROC __glewColorTableEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT; + +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT; + +GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT; + +GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT; + +GLEW_FUN_EXPORT PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT; +GLEW_FUN_EXPORT PFNGLENDSCENEEXTPROC __glewEndSceneEXT; + +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT; + +GLEW_FUN_EXPORT PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT; +GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT; +GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT; + +GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT; +GLEW_FUN_EXPORT PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT; + +GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT; + +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT; + +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT; + +GLEW_FUN_EXPORT PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT; + +GLEW_FUN_EXPORT PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT; +GLEW_FUN_EXPORT PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT; + +GLEW_FUN_EXPORT PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT; +GLEW_FUN_EXPORT PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT; +GLEW_FUN_EXPORT PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT; +GLEW_FUN_EXPORT PFNGLISTEXTUREEXTPROC __glewIsTextureEXT; +GLEW_FUN_EXPORT PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT; + +GLEW_FUN_EXPORT PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT; + +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT; + +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT; + +GLEW_FUN_EXPORT PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT; +GLEW_FUN_EXPORT PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT; +GLEW_FUN_EXPORT PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT; +GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT; +GLEW_FUN_EXPORT PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT; +GLEW_FUN_EXPORT PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT; + +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT; + +GLEW_FUN_EXPORT PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT; +GLEW_FUN_EXPORT PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT; +GLEW_FUN_EXPORT PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT; +GLEW_FUN_EXPORT PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT; +GLEW_FUN_EXPORT PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT; +GLEW_FUN_EXPORT PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT; +GLEW_FUN_EXPORT PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT; +GLEW_FUN_EXPORT PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT; +GLEW_FUN_EXPORT PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT; +GLEW_FUN_EXPORT PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT; +GLEW_FUN_EXPORT PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT; +GLEW_FUN_EXPORT PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT; +GLEW_FUN_EXPORT PFNGLSWIZZLEEXTPROC __glewSwizzleEXT; +GLEW_FUN_EXPORT PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT; +GLEW_FUN_EXPORT PFNGLVARIANTBVEXTPROC __glewVariantbvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTDVEXTPROC __glewVariantdvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTFVEXTPROC __glewVariantfvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTIVEXTPROC __glewVariantivEXT; +GLEW_FUN_EXPORT PFNGLVARIANTSVEXTPROC __glewVariantsvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT; +GLEW_FUN_EXPORT PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT; + +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT; + +GLEW_FUN_EXPORT PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT; + +GLEW_FUN_EXPORT PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY; + +GLEW_FUN_EXPORT PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY; + +GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP; +GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP; + +GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM; +GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM; + +GLEW_FUN_EXPORT PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM; +GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM; +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM; +GLEW_FUN_EXPORT PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM; +GLEW_FUN_EXPORT PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM; + +GLEW_FUN_EXPORT PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL; +GLEW_FUN_EXPORT PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL; + +GLEW_FUN_EXPORT PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL; +GLEW_FUN_EXPORT PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL; + +GLEW_FUN_EXPORT PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion; +GLEW_FUN_EXPORT PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion; +GLEW_FUN_EXPORT PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion; +GLEW_FUN_EXPORT PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion; + +GLEW_FUN_EXPORT PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA; + +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA; + +GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV; +GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV; + +GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV; +GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV; + +GLEW_FUN_EXPORT PFNGLEVALMAPSNVPROC __glewEvalMapsNV; +GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV; +GLEW_FUN_EXPORT PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV; +GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV; +GLEW_FUN_EXPORT PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV; +GLEW_FUN_EXPORT PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV; +GLEW_FUN_EXPORT PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV; + +GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV; +GLEW_FUN_EXPORT PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV; +GLEW_FUN_EXPORT PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV; + +GLEW_FUN_EXPORT PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV; +GLEW_FUN_EXPORT PFNGLFINISHFENCENVPROC __glewFinishFenceNV; +GLEW_FUN_EXPORT PFNGLGENFENCESNVPROC __glewGenFencesNV; +GLEW_FUN_EXPORT PFNGLGETFENCEIVNVPROC __glewGetFenceivNV; +GLEW_FUN_EXPORT PFNGLISFENCENVPROC __glewIsFenceNV; +GLEW_FUN_EXPORT PFNGLSETFENCENVPROC __glewSetFenceNV; +GLEW_FUN_EXPORT PFNGLTESTFENCENVPROC __glewTestFenceNV; + +GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV; + +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV; + +GLEW_FUN_EXPORT PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV; +GLEW_FUN_EXPORT PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV; +GLEW_FUN_EXPORT PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV; + +GLEW_FUN_EXPORT PFNGLCOLOR3HNVPROC __glewColor3hNV; +GLEW_FUN_EXPORT PFNGLCOLOR3HVNVPROC __glewColor3hvNV; +GLEW_FUN_EXPORT PFNGLCOLOR4HNVPROC __glewColor4hNV; +GLEW_FUN_EXPORT PFNGLCOLOR4HVNVPROC __glewColor4hvNV; +GLEW_FUN_EXPORT PFNGLFOGCOORDHNVPROC __glewFogCoordhNV; +GLEW_FUN_EXPORT PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV; +GLEW_FUN_EXPORT PFNGLNORMAL3HNVPROC __glewNormal3hNV; +GLEW_FUN_EXPORT PFNGLNORMAL3HVNVPROC __glewNormal3hvNV; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX2HNVPROC __glewVertex2hNV; +GLEW_FUN_EXPORT PFNGLVERTEX2HVNVPROC __glewVertex2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX3HNVPROC __glewVertex3hNV; +GLEW_FUN_EXPORT PFNGLVERTEX3HVNVPROC __glewVertex3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX4HNVPROC __glewVertex4hNV; +GLEW_FUN_EXPORT PFNGLVERTEX4HVNVPROC __glewVertex4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV; + +GLEW_FUN_EXPORT PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV; +GLEW_FUN_EXPORT PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV; +GLEW_FUN_EXPORT PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV; +GLEW_FUN_EXPORT PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV; +GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV; +GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV; +GLEW_FUN_EXPORT PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV; + +GLEW_FUN_EXPORT PFNGLCOPYPATHNVPROC __glewCopyPathNV; +GLEW_FUN_EXPORT PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV; +GLEW_FUN_EXPORT PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV; +GLEW_FUN_EXPORT PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV; +GLEW_FUN_EXPORT PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV; +GLEW_FUN_EXPORT PFNGLDELETEPATHSNVPROC __glewDeletePathsNV; +GLEW_FUN_EXPORT PFNGLGENPATHSNVPROC __glewGenPathsNV; +GLEW_FUN_EXPORT PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV; +GLEW_FUN_EXPORT PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV; +GLEW_FUN_EXPORT PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV; +GLEW_FUN_EXPORT PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV; +GLEW_FUN_EXPORT PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV; +GLEW_FUN_EXPORT PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV; +GLEW_FUN_EXPORT PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV; +GLEW_FUN_EXPORT PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV; +GLEW_FUN_EXPORT PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV; +GLEW_FUN_EXPORT PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV; +GLEW_FUN_EXPORT PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV; +GLEW_FUN_EXPORT PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV; +GLEW_FUN_EXPORT PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV; +GLEW_FUN_EXPORT PFNGLISPATHNVPROC __glewIsPathNV; +GLEW_FUN_EXPORT PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV; +GLEW_FUN_EXPORT PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV; +GLEW_FUN_EXPORT PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV; +GLEW_FUN_EXPORT PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV; +GLEW_FUN_EXPORT PFNGLPATHCOORDSNVPROC __glewPathCoordsNV; +GLEW_FUN_EXPORT PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV; +GLEW_FUN_EXPORT PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV; +GLEW_FUN_EXPORT PFNGLPATHFOGGENNVPROC __glewPathFogGenNV; +GLEW_FUN_EXPORT PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV; +GLEW_FUN_EXPORT PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV; +GLEW_FUN_EXPORT PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV; +GLEW_FUN_EXPORT PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV; +GLEW_FUN_EXPORT PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV; +GLEW_FUN_EXPORT PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV; +GLEW_FUN_EXPORT PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV; +GLEW_FUN_EXPORT PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV; +GLEW_FUN_EXPORT PFNGLPATHSTRINGNVPROC __glewPathStringNV; +GLEW_FUN_EXPORT PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV; +GLEW_FUN_EXPORT PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV; +GLEW_FUN_EXPORT PFNGLPATHTEXGENNVPROC __glewPathTexGenNV; +GLEW_FUN_EXPORT PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV; +GLEW_FUN_EXPORT PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV; +GLEW_FUN_EXPORT PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV; +GLEW_FUN_EXPORT PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV; +GLEW_FUN_EXPORT PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV; +GLEW_FUN_EXPORT PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV; +GLEW_FUN_EXPORT PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV; + +GLEW_FUN_EXPORT PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV; +GLEW_FUN_EXPORT PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV; + +GLEW_FUN_EXPORT PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV; +GLEW_FUN_EXPORT PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV; +GLEW_FUN_EXPORT PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV; + +GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV; +GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV; + +GLEW_FUN_EXPORT PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV; +GLEW_FUN_EXPORT PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV; +GLEW_FUN_EXPORT PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV; +GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV; + +GLEW_FUN_EXPORT PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV; + +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV; +GLEW_FUN_EXPORT PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV; +GLEW_FUN_EXPORT PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV; +GLEW_FUN_EXPORT PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV; +GLEW_FUN_EXPORT PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV; +GLEW_FUN_EXPORT PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV; +GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV; +GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV; +GLEW_FUN_EXPORT PFNGLUNIFORMUI64NVPROC __glewUniformui64NV; +GLEW_FUN_EXPORT PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV; + +GLEW_FUN_EXPORT PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV; + +GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV; + +GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV; +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV; +GLEW_FUN_EXPORT PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV; + +GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV; +GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV; + +GLEW_FUN_EXPORT PFNGLVDPAUFININVPROC __glewVDPAUFiniNV; +GLEW_FUN_EXPORT PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV; +GLEW_FUN_EXPORT PFNGLVDPAUINITNVPROC __glewVDPAUInitNV; +GLEW_FUN_EXPORT PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV; +GLEW_FUN_EXPORT PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV; +GLEW_FUN_EXPORT PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV; +GLEW_FUN_EXPORT PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV; +GLEW_FUN_EXPORT PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV; +GLEW_FUN_EXPORT PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV; +GLEW_FUN_EXPORT PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV; + +GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV; + +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV; + +GLEW_FUN_EXPORT PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV; +GLEW_FUN_EXPORT PFNGLCOLORFORMATNVPROC __glewColorFormatNV; +GLEW_FUN_EXPORT PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV; +GLEW_FUN_EXPORT PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV; +GLEW_FUN_EXPORT PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV; +GLEW_FUN_EXPORT PFNGLINDEXFORMATNVPROC __glewIndexFormatNV; +GLEW_FUN_EXPORT PFNGLNORMALFORMATNVPROC __glewNormalFormatNV; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV; +GLEW_FUN_EXPORT PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV; +GLEW_FUN_EXPORT PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV; + +GLEW_FUN_EXPORT PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV; +GLEW_FUN_EXPORT PFNGLBINDPROGRAMNVPROC __glewBindProgramNV; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV; +GLEW_FUN_EXPORT PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV; +GLEW_FUN_EXPORT PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV; +GLEW_FUN_EXPORT PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV; +GLEW_FUN_EXPORT PFNGLISPROGRAMNVPROC __glewIsProgramNV; +GLEW_FUN_EXPORT PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV; +GLEW_FUN_EXPORT PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV; +GLEW_FUN_EXPORT PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV; + +GLEW_FUN_EXPORT PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV; +GLEW_FUN_EXPORT PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV; +GLEW_FUN_EXPORT PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV; +GLEW_FUN_EXPORT PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV; +GLEW_FUN_EXPORT PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV; +GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV; +GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV; +GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES; +GLEW_FUN_EXPORT PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES; +GLEW_FUN_EXPORT PFNGLFRUSTUMFOESPROC __glewFrustumfOES; +GLEW_FUN_EXPORT PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES; +GLEW_FUN_EXPORT PFNGLORTHOFOESPROC __glewOrthofOES; + +GLEW_FUN_EXPORT PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS; +GLEW_FUN_EXPORT PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS; + +GLEW_FUN_EXPORT PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS; +GLEW_FUN_EXPORT PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS; + +GLEW_FUN_EXPORT PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS; +GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS; + +GLEW_FUN_EXPORT PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS; +GLEW_FUN_EXPORT PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS; + +GLEW_FUN_EXPORT PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS; + +GLEW_FUN_EXPORT PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS; +GLEW_FUN_EXPORT PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS; + +GLEW_FUN_EXPORT PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX; +GLEW_FUN_EXPORT PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX; +GLEW_FUN_EXPORT PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX; +GLEW_FUN_EXPORT PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX; +GLEW_FUN_EXPORT PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX; +GLEW_FUN_EXPORT PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX; + +GLEW_FUN_EXPORT PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX; + +GLEW_FUN_EXPORT PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX; + +GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX; + +GLEW_FUN_EXPORT PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX; + +GLEW_FUN_EXPORT PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX; + +GLEW_FUN_EXPORT PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX; + +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX; + +GLEW_FUN_EXPORT PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX; + +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI; +GLEW_FUN_EXPORT PFNGLCOLORTABLESGIPROC __glewColorTableSGI; +GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI; + +GLEW_FUN_EXPORT PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX; + +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN; + +GLEW_FUN_EXPORT PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN; + +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN; + +GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN; + +GLEW_FUN_EXPORT PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN; + +#if defined(GLEW_MX) && !defined(_WIN32) +struct GLEWContextStruct +{ +#endif /* GLEW_MX */ + +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_3; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_4; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_5; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_0; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_0; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_2; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_3; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_0; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_2; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_tbuffer; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_texture_compression_FXT1; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_blend_minmax_factor; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_conservative_depth; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_debug_output; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_depth_clamp_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_draw_buffers_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_multi_draw_indirect; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_name_gen_delete; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_performance_monitor; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_sample_positions; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_seamless_cubemap_per_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_export; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_texture_texture4; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_transform_feedback3_lines_triangles; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_tessellator; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_aux_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_client_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_element_array; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_fence; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_float_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_flush_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_object_purgeable; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_pixel_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_rgb_422; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_row_bytes; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_specular_vector; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_transform_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_program_evaluators; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_ycbcr_422; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_ES2_compatibility; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_base_instance; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_blend_func_extended; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_cl_event; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_color_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compatibility; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compressed_texture_pixel_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_conservative_depth; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_copy_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_debug_output; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_elements_base_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_indirect; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_instanced; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_explicit_attrib_location; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_coord_conventions; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_get_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader5; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader_fp64; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_pixel; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_imaging; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_instanced_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_internalformat_query; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_map_buffer_alignment; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_map_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_matrix_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multitexture; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query2; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pixel_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_provoking_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_robustness; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sample_shading; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sampler_objects; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_seamless_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_separate_shader_objects; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_atomic_counters; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_bit_encoding; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_image_load_store; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_objects; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_precision; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_stencil_export; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_subroutine; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_100; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_420pack; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_include; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_packing; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow_ambient; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sync; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_tessellation_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object_rgb32; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_bptc; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_rgtc; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map_array; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_add; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_combine; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_crossbar; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_dot3; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_gather; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_mirrored_repeat; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_non_power_of_two; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_query_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rg; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rgb10_a2ui; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_swizzle; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_timer_query; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback2; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback3; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback_instanced; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transpose_matrix; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_uniform_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_attrib_64bit; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_program; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_viewport_array; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_point_sprites; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_combine3; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_route; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_vertex_shader_output_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_element_array; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_envmap_bumpmap; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_map_object_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_meminfo; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_pn_triangles; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_separate_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_shader_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_text_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_compression_3dc; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_env_combine3; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_mirror_once; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_attrib_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_streams; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_422_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bindable_uniform; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_equation_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_func_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_logic_op; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_minmax; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_subtract; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_volume_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cmyka; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_subtable; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_compiled_vertex_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_convolution; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_coordinate_frame; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_copy_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cull_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_depth_bounds_test; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_direct_state_access; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers2; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_instanced; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_range_elements; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_program_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_histogram; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_array_formats; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_func; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_material; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_light_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_float; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_paletted_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_point_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_provoking_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_rescale_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_store; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_clear_tag; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_two_side; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_wrap; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_subtexture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture3D; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_dxt1; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_latc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_rgtc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_edge_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_add; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_combine; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_dot3; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_anisotropic; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_integer; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_lod_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_mirror_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB_decode; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_timer_query; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_transform_feedback; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_attrib_64bit; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_weighting; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_x11_sync_object; +GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_frame_terminator; +GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_string_marker; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_image_transform; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_occlusion_test; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_texture_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_cull_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_multimode_draw_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_static_data; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_texture_mirrored_repeat; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_vertex_array_lists; +GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read; +GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_parallel_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_texture_scissor; +GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region; +GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_NVX_gpu_memory_info; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_square; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_conditional_render; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_depth_to_color; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_image; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_range_unclamped; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_evaluators; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_explicit_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fence; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_float_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fog_distance; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program_option; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program5; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program_fp64; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_shader5; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_half_float; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_occlusion_query; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_path_rendering; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_data_range; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_buffer_load; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_tessellation_program5; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_emboss; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_reflection; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_barrier; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_vtc; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_env_combine4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_expand_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_attrib_integer_64bit; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_buffer_unified_memory; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program1_1; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2_option; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program3; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_video_capture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_byte_coordinates; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_paletted_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_read_format; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_single_precision; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_interlace; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_resample; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_subsample; +GLEW_VAR_EXPORT GLboolean __GLEW_PGI_misc_hints; +GLEW_VAR_EXPORT GLboolean __GLEW_PGI_vertex_hints; +GLEW_VAR_EXPORT GLboolean __GLEW_REND_screen_coordinates; +GLEW_VAR_EXPORT GLboolean __GLEW_S3_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_color_range; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_detail_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_fog_function; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_generate_mipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_pixel_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_point_line_texgen; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_sharpen_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture4D; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_edge_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_filter4; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_select; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_histogram; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_pixel; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_alpha_minmax; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_clipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_convolution_accuracy; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_flush_raster; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_offset; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragment_specular_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_framezoom; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_interlace; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ir_instrument1; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_list_priority; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture_bits; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_reference_plane; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_resample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow_ambient; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_tag_sample_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_add_env; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_coordinate_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_lod_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_multi_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_range; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_scale_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcb; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_matrix; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_texture_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_SUNX_constant_data; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_convolution_border_modes; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_global_alpha; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_mesh_array; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_read_video_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_slice_accum; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_triangle_list; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_phong_shading; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_specular_fog; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; + +#ifdef GLEW_MX +}; /* GLEWContextStruct */ +#endif /* GLEW_MX */ + +/* ------------------------------------------------------------------------- */ + +/* error codes */ +#define GLEW_OK 0 +#define GLEW_NO_ERROR 0 +#define GLEW_ERROR_NO_GL_VERSION 1 /* missing GL version */ +#define GLEW_ERROR_GL_VERSION_10_ONLY 2 /* Need at least OpenGL 1.1 */ +#define GLEW_ERROR_GLX_VERSION_11_ONLY 3 /* Need at least GLX 1.2 */ + +/* string codes */ +#define GLEW_VERSION 1 +#define GLEW_VERSION_MAJOR 2 +#define GLEW_VERSION_MINOR 3 +#define GLEW_VERSION_MICRO 4 + +/* API */ +#ifdef GLEW_MX + +typedef struct GLEWContextStruct GLEWContext; +GLEWAPI GLenum glewContextInit (GLEWContext* ctx); +GLEWAPI GLboolean glewContextIsSupported (const GLEWContext* ctx, const char* name); + +#define glewInit() glewContextInit(glewGetContext()) +#define glewIsSupported(x) glewContextIsSupported(glewGetContext(), x) +#define glewIsExtensionSupported(x) glewIsSupported(x) + +#define GLEW_GET_VAR(x) (*(const GLboolean*)&(glewGetContext()->x)) +#ifdef _WIN32 +# define GLEW_GET_FUN(x) glewGetContext()->x +#else +# define GLEW_GET_FUN(x) x +#endif + +#else /* GLEW_MX */ + +GLEWAPI GLenum glewInit (); +GLEWAPI GLboolean glewIsSupported (const char* name); +#define glewIsExtensionSupported(x) glewIsSupported(x) + +#define GLEW_GET_VAR(x) (*(const GLboolean*)&x) +#define GLEW_GET_FUN(x) x + +#endif /* GLEW_MX */ + +GLEWAPI GLboolean glewExperimental; +GLEWAPI GLboolean glewGetExtension (const char* name); +GLEWAPI const GLubyte* glewGetErrorString (GLenum error); +GLEWAPI const GLubyte* glewGetString (GLenum name); + +#ifdef __cplusplus +} +#endif + +#ifdef GLEW_APIENTRY_DEFINED +#undef GLEW_APIENTRY_DEFINED +#undef APIENTRY +#undef GLAPIENTRY +#define GLAPIENTRY +#endif + +#ifdef GLEW_CALLBACK_DEFINED +#undef GLEW_CALLBACK_DEFINED +#undef CALLBACK +#endif + +#ifdef GLEW_WINGDIAPI_DEFINED +#undef GLEW_WINGDIAPI_DEFINED +#undef WINGDIAPI +#endif + +#undef GLAPI +/* #undef GLEWAPI */ + +#endif /* __glew_h__ */ diff --git a/lib/glew/glxew.h b/lib/glew/glxew.h new file mode 100644 index 0000000..6d249f7 --- /dev/null +++ b/lib/glew/glxew.h @@ -0,0 +1,1587 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* + * Mesa 3-D graphics library + * Version: 7.0 + * + * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* +** Copyright (c) 2007 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __glxew_h__ +#define __glxew_h__ +#define __GLXEW_H__ + +#ifdef __glxext_h_ +#error glxext.h included before glxew.h +#endif + +#if defined(GLX_H) || defined(__GLX_glx_h__) || defined(__glx_h__) +#error glx.h included before glxew.h +#endif + +#define __glxext_h_ + +#define GLX_H +#define __GLX_glx_h__ +#define __glx_h__ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ---------------------------- GLX_VERSION_1_0 --------------------------- */ + +#ifndef GLX_VERSION_1_0 +#define GLX_VERSION_1_0 1 + +#define GLX_USE_GL 1 +#define GLX_BUFFER_SIZE 2 +#define GLX_LEVEL 3 +#define GLX_RGBA 4 +#define GLX_DOUBLEBUFFER 5 +#define GLX_STEREO 6 +#define GLX_AUX_BUFFERS 7 +#define GLX_RED_SIZE 8 +#define GLX_GREEN_SIZE 9 +#define GLX_BLUE_SIZE 10 +#define GLX_ALPHA_SIZE 11 +#define GLX_DEPTH_SIZE 12 +#define GLX_STENCIL_SIZE 13 +#define GLX_ACCUM_RED_SIZE 14 +#define GLX_ACCUM_GREEN_SIZE 15 +#define GLX_ACCUM_BLUE_SIZE 16 +#define GLX_ACCUM_ALPHA_SIZE 17 +#define GLX_BAD_SCREEN 1 +#define GLX_BAD_ATTRIBUTE 2 +#define GLX_NO_EXTENSION 3 +#define GLX_BAD_VISUAL 4 +#define GLX_BAD_CONTEXT 5 +#define GLX_BAD_VALUE 6 +#define GLX_BAD_ENUM 7 + +typedef XID GLXDrawable; +typedef XID GLXPixmap; +#ifdef __sun +typedef struct __glXContextRec *GLXContext; +#else +typedef struct __GLXcontextRec *GLXContext; +#endif + +typedef unsigned int GLXVideoDeviceNV; + +extern Bool glXQueryExtension (Display *dpy, int *errorBase, int *eventBase); +extern Bool glXQueryVersion (Display *dpy, int *major, int *minor); +extern int glXGetConfig (Display *dpy, XVisualInfo *vis, int attrib, int *value); +extern XVisualInfo* glXChooseVisual (Display *dpy, int screen, int *attribList); +extern GLXPixmap glXCreateGLXPixmap (Display *dpy, XVisualInfo *vis, Pixmap pixmap); +extern void glXDestroyGLXPixmap (Display *dpy, GLXPixmap pix); +extern GLXContext glXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct); +extern void glXDestroyContext (Display *dpy, GLXContext ctx); +extern Bool glXIsDirect (Display *dpy, GLXContext ctx); +extern void glXCopyContext (Display *dpy, GLXContext src, GLXContext dst, GLulong mask); +extern Bool glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx); +extern GLXContext glXGetCurrentContext (void); +extern GLXDrawable glXGetCurrentDrawable (void); +extern void glXWaitGL (void); +extern void glXWaitX (void); +extern void glXSwapBuffers (Display *dpy, GLXDrawable drawable); +extern void glXUseXFont (Font font, int first, int count, int listBase); + +#define GLXEW_VERSION_1_0 GLXEW_GET_VAR(__GLXEW_VERSION_1_0) + +#endif /* GLX_VERSION_1_0 */ + +/* ---------------------------- GLX_VERSION_1_1 --------------------------- */ + +#ifndef GLX_VERSION_1_1 +#define GLX_VERSION_1_1 + +#define GLX_VENDOR 0x1 +#define GLX_VERSION 0x2 +#define GLX_EXTENSIONS 0x3 + +extern const char* glXQueryExtensionsString (Display *dpy, int screen); +extern const char* glXGetClientString (Display *dpy, int name); +extern const char* glXQueryServerString (Display *dpy, int screen, int name); + +#define GLXEW_VERSION_1_1 GLXEW_GET_VAR(__GLXEW_VERSION_1_1) + +#endif /* GLX_VERSION_1_1 */ + +/* ---------------------------- GLX_VERSION_1_2 ---------------------------- */ + +#ifndef GLX_VERSION_1_2 +#define GLX_VERSION_1_2 1 + +typedef Display* ( * PFNGLXGETCURRENTDISPLAYPROC) (void); + +#define glXGetCurrentDisplay GLXEW_GET_FUN(__glewXGetCurrentDisplay) + +#define GLXEW_VERSION_1_2 GLXEW_GET_VAR(__GLXEW_VERSION_1_2) + +#endif /* GLX_VERSION_1_2 */ + +/* ---------------------------- GLX_VERSION_1_3 ---------------------------- */ + +#ifndef GLX_VERSION_1_3 +#define GLX_VERSION_1_3 1 + +#define GLX_RGBA_BIT 0x00000001 +#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001 +#define GLX_WINDOW_BIT 0x00000001 +#define GLX_COLOR_INDEX_BIT 0x00000002 +#define GLX_PIXMAP_BIT 0x00000002 +#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002 +#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004 +#define GLX_PBUFFER_BIT 0x00000004 +#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008 +#define GLX_AUX_BUFFERS_BIT 0x00000010 +#define GLX_CONFIG_CAVEAT 0x20 +#define GLX_DEPTH_BUFFER_BIT 0x00000020 +#define GLX_X_VISUAL_TYPE 0x22 +#define GLX_TRANSPARENT_TYPE 0x23 +#define GLX_TRANSPARENT_INDEX_VALUE 0x24 +#define GLX_TRANSPARENT_RED_VALUE 0x25 +#define GLX_TRANSPARENT_GREEN_VALUE 0x26 +#define GLX_TRANSPARENT_BLUE_VALUE 0x27 +#define GLX_TRANSPARENT_ALPHA_VALUE 0x28 +#define GLX_STENCIL_BUFFER_BIT 0x00000040 +#define GLX_ACCUM_BUFFER_BIT 0x00000080 +#define GLX_NONE 0x8000 +#define GLX_SLOW_CONFIG 0x8001 +#define GLX_TRUE_COLOR 0x8002 +#define GLX_DIRECT_COLOR 0x8003 +#define GLX_PSEUDO_COLOR 0x8004 +#define GLX_STATIC_COLOR 0x8005 +#define GLX_GRAY_SCALE 0x8006 +#define GLX_STATIC_GRAY 0x8007 +#define GLX_TRANSPARENT_RGB 0x8008 +#define GLX_TRANSPARENT_INDEX 0x8009 +#define GLX_VISUAL_ID 0x800B +#define GLX_SCREEN 0x800C +#define GLX_NON_CONFORMANT_CONFIG 0x800D +#define GLX_DRAWABLE_TYPE 0x8010 +#define GLX_RENDER_TYPE 0x8011 +#define GLX_X_RENDERABLE 0x8012 +#define GLX_FBCONFIG_ID 0x8013 +#define GLX_RGBA_TYPE 0x8014 +#define GLX_COLOR_INDEX_TYPE 0x8015 +#define GLX_MAX_PBUFFER_WIDTH 0x8016 +#define GLX_MAX_PBUFFER_HEIGHT 0x8017 +#define GLX_MAX_PBUFFER_PIXELS 0x8018 +#define GLX_PRESERVED_CONTENTS 0x801B +#define GLX_LARGEST_PBUFFER 0x801C +#define GLX_WIDTH 0x801D +#define GLX_HEIGHT 0x801E +#define GLX_EVENT_MASK 0x801F +#define GLX_DAMAGED 0x8020 +#define GLX_SAVED 0x8021 +#define GLX_WINDOW 0x8022 +#define GLX_PBUFFER 0x8023 +#define GLX_PBUFFER_HEIGHT 0x8040 +#define GLX_PBUFFER_WIDTH 0x8041 +#define GLX_PBUFFER_CLOBBER_MASK 0x08000000 +#define GLX_DONT_CARE 0xFFFFFFFF + +typedef XID GLXFBConfigID; +typedef XID GLXPbuffer; +typedef XID GLXWindow; +typedef struct __GLXFBConfigRec *GLXFBConfig; + +typedef struct { + int event_type; + int draw_type; + unsigned long serial; + Bool send_event; + Display *display; + GLXDrawable drawable; + unsigned int buffer_mask; + unsigned int aux_buffer; + int x, y; + int width, height; + int count; +} GLXPbufferClobberEvent; +typedef union __GLXEvent { + GLXPbufferClobberEvent glxpbufferclobber; + long pad[24]; +} GLXEvent; + +typedef GLXFBConfig* ( * PFNGLXCHOOSEFBCONFIGPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements); +typedef GLXContext ( * PFNGLXCREATENEWCONTEXTPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct); +typedef GLXPbuffer ( * PFNGLXCREATEPBUFFERPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list); +typedef GLXPixmap ( * PFNGLXCREATEPIXMAPPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list); +typedef GLXWindow ( * PFNGLXCREATEWINDOWPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list); +typedef void ( * PFNGLXDESTROYPBUFFERPROC) (Display *dpy, GLXPbuffer pbuf); +typedef void ( * PFNGLXDESTROYPIXMAPPROC) (Display *dpy, GLXPixmap pixmap); +typedef void ( * PFNGLXDESTROYWINDOWPROC) (Display *dpy, GLXWindow win); +typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLEPROC) (void); +typedef int ( * PFNGLXGETFBCONFIGATTRIBPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value); +typedef GLXFBConfig* ( * PFNGLXGETFBCONFIGSPROC) (Display *dpy, int screen, int *nelements); +typedef void ( * PFNGLXGETSELECTEDEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask); +typedef XVisualInfo* ( * PFNGLXGETVISUALFROMFBCONFIGPROC) (Display *dpy, GLXFBConfig config); +typedef Bool ( * PFNGLXMAKECONTEXTCURRENTPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx); +typedef int ( * PFNGLXQUERYCONTEXTPROC) (Display *dpy, GLXContext ctx, int attribute, int *value); +typedef void ( * PFNGLXQUERYDRAWABLEPROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value); +typedef void ( * PFNGLXSELECTEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask); + +#define glXChooseFBConfig GLXEW_GET_FUN(__glewXChooseFBConfig) +#define glXCreateNewContext GLXEW_GET_FUN(__glewXCreateNewContext) +#define glXCreatePbuffer GLXEW_GET_FUN(__glewXCreatePbuffer) +#define glXCreatePixmap GLXEW_GET_FUN(__glewXCreatePixmap) +#define glXCreateWindow GLXEW_GET_FUN(__glewXCreateWindow) +#define glXDestroyPbuffer GLXEW_GET_FUN(__glewXDestroyPbuffer) +#define glXDestroyPixmap GLXEW_GET_FUN(__glewXDestroyPixmap) +#define glXDestroyWindow GLXEW_GET_FUN(__glewXDestroyWindow) +#define glXGetCurrentReadDrawable GLXEW_GET_FUN(__glewXGetCurrentReadDrawable) +#define glXGetFBConfigAttrib GLXEW_GET_FUN(__glewXGetFBConfigAttrib) +#define glXGetFBConfigs GLXEW_GET_FUN(__glewXGetFBConfigs) +#define glXGetSelectedEvent GLXEW_GET_FUN(__glewXGetSelectedEvent) +#define glXGetVisualFromFBConfig GLXEW_GET_FUN(__glewXGetVisualFromFBConfig) +#define glXMakeContextCurrent GLXEW_GET_FUN(__glewXMakeContextCurrent) +#define glXQueryContext GLXEW_GET_FUN(__glewXQueryContext) +#define glXQueryDrawable GLXEW_GET_FUN(__glewXQueryDrawable) +#define glXSelectEvent GLXEW_GET_FUN(__glewXSelectEvent) + +#define GLXEW_VERSION_1_3 GLXEW_GET_VAR(__GLXEW_VERSION_1_3) + +#endif /* GLX_VERSION_1_3 */ + +/* ---------------------------- GLX_VERSION_1_4 ---------------------------- */ + +#ifndef GLX_VERSION_1_4 +#define GLX_VERSION_1_4 1 + +#define GLX_SAMPLE_BUFFERS 100000 +#define GLX_SAMPLES 100001 + +extern void ( * glXGetProcAddress (const GLubyte *procName)) (void); + +#define GLXEW_VERSION_1_4 GLXEW_GET_VAR(__GLXEW_VERSION_1_4) + +#endif /* GLX_VERSION_1_4 */ + +/* -------------------------- GLX_3DFX_multisample ------------------------- */ + +#ifndef GLX_3DFX_multisample +#define GLX_3DFX_multisample 1 + +#define GLX_SAMPLE_BUFFERS_3DFX 0x8050 +#define GLX_SAMPLES_3DFX 0x8051 + +#define GLXEW_3DFX_multisample GLXEW_GET_VAR(__GLXEW_3DFX_multisample) + +#endif /* GLX_3DFX_multisample */ + +/* ------------------------ GLX_AMD_gpu_association ------------------------ */ + +#ifndef GLX_AMD_gpu_association +#define GLX_AMD_gpu_association 1 + +#define GLX_GPU_VENDOR_AMD 0x1F00 +#define GLX_GPU_RENDERER_STRING_AMD 0x1F01 +#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 +#define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 +#define GLX_GPU_RAM_AMD 0x21A3 +#define GLX_GPU_CLOCK_AMD 0x21A4 +#define GLX_GPU_NUM_PIPES_AMD 0x21A5 +#define GLX_GPU_NUM_SIMD_AMD 0x21A6 +#define GLX_GPU_NUM_RB_AMD 0x21A7 +#define GLX_GPU_NUM_SPI_AMD 0x21A8 + +#define GLXEW_AMD_gpu_association GLXEW_GET_VAR(__GLXEW_AMD_gpu_association) + +#endif /* GLX_AMD_gpu_association */ + +/* ------------------------- GLX_ARB_create_context ------------------------ */ + +#ifndef GLX_ARB_create_context +#define GLX_ARB_create_context 1 + +#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define GLX_CONTEXT_FLAGS_ARB 0x2094 + +typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list); + +#define glXCreateContextAttribsARB GLXEW_GET_FUN(__glewXCreateContextAttribsARB) + +#define GLXEW_ARB_create_context GLXEW_GET_VAR(__GLXEW_ARB_create_context) + +#endif /* GLX_ARB_create_context */ + +/* --------------------- GLX_ARB_create_context_profile -------------------- */ + +#ifndef GLX_ARB_create_context_profile +#define GLX_ARB_create_context_profile 1 + +#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 +#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 +#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126 + +#define GLXEW_ARB_create_context_profile GLXEW_GET_VAR(__GLXEW_ARB_create_context_profile) + +#endif /* GLX_ARB_create_context_profile */ + +/* ------------------- GLX_ARB_create_context_robustness ------------------- */ + +#ifndef GLX_ARB_create_context_robustness +#define GLX_ARB_create_context_robustness 1 + +#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 +#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252 +#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 +#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261 + +#define GLXEW_ARB_create_context_robustness GLXEW_GET_VAR(__GLXEW_ARB_create_context_robustness) + +#endif /* GLX_ARB_create_context_robustness */ + +/* ------------------------- GLX_ARB_fbconfig_float ------------------------ */ + +#ifndef GLX_ARB_fbconfig_float +#define GLX_ARB_fbconfig_float 1 + +#define GLX_RGBA_FLOAT_BIT 0x00000004 +#define GLX_RGBA_FLOAT_TYPE 0x20B9 + +#define GLXEW_ARB_fbconfig_float GLXEW_GET_VAR(__GLXEW_ARB_fbconfig_float) + +#endif /* GLX_ARB_fbconfig_float */ + +/* ------------------------ GLX_ARB_framebuffer_sRGB ----------------------- */ + +#ifndef GLX_ARB_framebuffer_sRGB +#define GLX_ARB_framebuffer_sRGB 1 + +#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2 + +#define GLXEW_ARB_framebuffer_sRGB GLXEW_GET_VAR(__GLXEW_ARB_framebuffer_sRGB) + +#endif /* GLX_ARB_framebuffer_sRGB */ + +/* ------------------------ GLX_ARB_get_proc_address ----------------------- */ + +#ifndef GLX_ARB_get_proc_address +#define GLX_ARB_get_proc_address 1 + +extern void ( * glXGetProcAddressARB (const GLubyte *procName)) (void); + +#define GLXEW_ARB_get_proc_address GLXEW_GET_VAR(__GLXEW_ARB_get_proc_address) + +#endif /* GLX_ARB_get_proc_address */ + +/* -------------------------- GLX_ARB_multisample -------------------------- */ + +#ifndef GLX_ARB_multisample +#define GLX_ARB_multisample 1 + +#define GLX_SAMPLE_BUFFERS_ARB 100000 +#define GLX_SAMPLES_ARB 100001 + +#define GLXEW_ARB_multisample GLXEW_GET_VAR(__GLXEW_ARB_multisample) + +#endif /* GLX_ARB_multisample */ + +/* ---------------------- GLX_ARB_vertex_buffer_object --------------------- */ + +#ifndef GLX_ARB_vertex_buffer_object +#define GLX_ARB_vertex_buffer_object 1 + +#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095 + +#define GLXEW_ARB_vertex_buffer_object GLXEW_GET_VAR(__GLXEW_ARB_vertex_buffer_object) + +#endif /* GLX_ARB_vertex_buffer_object */ + +/* ----------------------- GLX_ATI_pixel_format_float ---------------------- */ + +#ifndef GLX_ATI_pixel_format_float +#define GLX_ATI_pixel_format_float 1 + +#define GLX_RGBA_FLOAT_ATI_BIT 0x00000100 + +#define GLXEW_ATI_pixel_format_float GLXEW_GET_VAR(__GLXEW_ATI_pixel_format_float) + +#endif /* GLX_ATI_pixel_format_float */ + +/* ------------------------- GLX_ATI_render_texture ------------------------ */ + +#ifndef GLX_ATI_render_texture +#define GLX_ATI_render_texture 1 + +#define GLX_BIND_TO_TEXTURE_RGB_ATI 0x9800 +#define GLX_BIND_TO_TEXTURE_RGBA_ATI 0x9801 +#define GLX_TEXTURE_FORMAT_ATI 0x9802 +#define GLX_TEXTURE_TARGET_ATI 0x9803 +#define GLX_MIPMAP_TEXTURE_ATI 0x9804 +#define GLX_TEXTURE_RGB_ATI 0x9805 +#define GLX_TEXTURE_RGBA_ATI 0x9806 +#define GLX_NO_TEXTURE_ATI 0x9807 +#define GLX_TEXTURE_CUBE_MAP_ATI 0x9808 +#define GLX_TEXTURE_1D_ATI 0x9809 +#define GLX_TEXTURE_2D_ATI 0x980A +#define GLX_MIPMAP_LEVEL_ATI 0x980B +#define GLX_CUBE_MAP_FACE_ATI 0x980C +#define GLX_TEXTURE_CUBE_MAP_POSITIVE_X_ATI 0x980D +#define GLX_TEXTURE_CUBE_MAP_NEGATIVE_X_ATI 0x980E +#define GLX_TEXTURE_CUBE_MAP_POSITIVE_Y_ATI 0x980F +#define GLX_TEXTURE_CUBE_MAP_NEGATIVE_Y_ATI 0x9810 +#define GLX_TEXTURE_CUBE_MAP_POSITIVE_Z_ATI 0x9811 +#define GLX_TEXTURE_CUBE_MAP_NEGATIVE_Z_ATI 0x9812 +#define GLX_FRONT_LEFT_ATI 0x9813 +#define GLX_FRONT_RIGHT_ATI 0x9814 +#define GLX_BACK_LEFT_ATI 0x9815 +#define GLX_BACK_RIGHT_ATI 0x9816 +#define GLX_AUX0_ATI 0x9817 +#define GLX_AUX1_ATI 0x9818 +#define GLX_AUX2_ATI 0x9819 +#define GLX_AUX3_ATI 0x981A +#define GLX_AUX4_ATI 0x981B +#define GLX_AUX5_ATI 0x981C +#define GLX_AUX6_ATI 0x981D +#define GLX_AUX7_ATI 0x981E +#define GLX_AUX8_ATI 0x981F +#define GLX_AUX9_ATI 0x9820 +#define GLX_BIND_TO_TEXTURE_LUMINANCE_ATI 0x9821 +#define GLX_BIND_TO_TEXTURE_INTENSITY_ATI 0x9822 + +typedef void ( * PFNGLXBINDTEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, int buffer); +typedef void ( * PFNGLXDRAWABLEATTRIBATIPROC) (Display *dpy, GLXDrawable draw, const int *attrib_list); +typedef void ( * PFNGLXRELEASETEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, int buffer); + +#define glXBindTexImageATI GLXEW_GET_FUN(__glewXBindTexImageATI) +#define glXDrawableAttribATI GLXEW_GET_FUN(__glewXDrawableAttribATI) +#define glXReleaseTexImageATI GLXEW_GET_FUN(__glewXReleaseTexImageATI) + +#define GLXEW_ATI_render_texture GLXEW_GET_VAR(__GLXEW_ATI_render_texture) + +#endif /* GLX_ATI_render_texture */ + +/* ------------------- GLX_EXT_create_context_es2_profile ------------------ */ + +#ifndef GLX_EXT_create_context_es2_profile +#define GLX_EXT_create_context_es2_profile 1 + +#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 + +#define GLXEW_EXT_create_context_es2_profile GLXEW_GET_VAR(__GLXEW_EXT_create_context_es2_profile) + +#endif /* GLX_EXT_create_context_es2_profile */ + +/* --------------------- GLX_EXT_fbconfig_packed_float --------------------- */ + +#ifndef GLX_EXT_fbconfig_packed_float +#define GLX_EXT_fbconfig_packed_float 1 + +#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008 +#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1 + +#define GLXEW_EXT_fbconfig_packed_float GLXEW_GET_VAR(__GLXEW_EXT_fbconfig_packed_float) + +#endif /* GLX_EXT_fbconfig_packed_float */ + +/* ------------------------ GLX_EXT_framebuffer_sRGB ----------------------- */ + +#ifndef GLX_EXT_framebuffer_sRGB +#define GLX_EXT_framebuffer_sRGB 1 + +#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2 + +#define GLXEW_EXT_framebuffer_sRGB GLXEW_GET_VAR(__GLXEW_EXT_framebuffer_sRGB) + +#endif /* GLX_EXT_framebuffer_sRGB */ + +/* ------------------------- GLX_EXT_import_context ------------------------ */ + +#ifndef GLX_EXT_import_context +#define GLX_EXT_import_context 1 + +#define GLX_SHARE_CONTEXT_EXT 0x800A +#define GLX_VISUAL_ID_EXT 0x800B +#define GLX_SCREEN_EXT 0x800C + +typedef XID GLXContextID; + +typedef void ( * PFNGLXFREECONTEXTEXTPROC) (Display* dpy, GLXContext context); +typedef GLXContextID ( * PFNGLXGETCONTEXTIDEXTPROC) (const GLXContext context); +typedef GLXContext ( * PFNGLXIMPORTCONTEXTEXTPROC) (Display* dpy, GLXContextID contextID); +typedef int ( * PFNGLXQUERYCONTEXTINFOEXTPROC) (Display* dpy, GLXContext context, int attribute,int *value); + +#define glXFreeContextEXT GLXEW_GET_FUN(__glewXFreeContextEXT) +#define glXGetContextIDEXT GLXEW_GET_FUN(__glewXGetContextIDEXT) +#define glXImportContextEXT GLXEW_GET_FUN(__glewXImportContextEXT) +#define glXQueryContextInfoEXT GLXEW_GET_FUN(__glewXQueryContextInfoEXT) + +#define GLXEW_EXT_import_context GLXEW_GET_VAR(__GLXEW_EXT_import_context) + +#endif /* GLX_EXT_import_context */ + +/* -------------------------- GLX_EXT_scene_marker ------------------------- */ + +#ifndef GLX_EXT_scene_marker +#define GLX_EXT_scene_marker 1 + +#define GLXEW_EXT_scene_marker GLXEW_GET_VAR(__GLXEW_EXT_scene_marker) + +#endif /* GLX_EXT_scene_marker */ + +/* -------------------------- GLX_EXT_swap_control ------------------------- */ + +#ifndef GLX_EXT_swap_control +#define GLX_EXT_swap_control 1 + +#define GLX_SWAP_INTERVAL_EXT 0x20F1 +#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2 + +typedef void ( * PFNGLXSWAPINTERVALEXTPROC) (Display* dpy, GLXDrawable drawable, int interval); + +#define glXSwapIntervalEXT GLXEW_GET_FUN(__glewXSwapIntervalEXT) + +#define GLXEW_EXT_swap_control GLXEW_GET_VAR(__GLXEW_EXT_swap_control) + +#endif /* GLX_EXT_swap_control */ + +/* ---------------------- GLX_EXT_texture_from_pixmap ---------------------- */ + +#ifndef GLX_EXT_texture_from_pixmap +#define GLX_EXT_texture_from_pixmap 1 + +#define GLX_TEXTURE_1D_BIT_EXT 0x00000001 +#define GLX_TEXTURE_2D_BIT_EXT 0x00000002 +#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004 +#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0 +#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1 +#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2 +#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3 +#define GLX_Y_INVERTED_EXT 0x20D4 +#define GLX_TEXTURE_FORMAT_EXT 0x20D5 +#define GLX_TEXTURE_TARGET_EXT 0x20D6 +#define GLX_MIPMAP_TEXTURE_EXT 0x20D7 +#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8 +#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9 +#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA +#define GLX_TEXTURE_1D_EXT 0x20DB +#define GLX_TEXTURE_2D_EXT 0x20DC +#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD +#define GLX_FRONT_LEFT_EXT 0x20DE +#define GLX_FRONT_RIGHT_EXT 0x20DF +#define GLX_BACK_LEFT_EXT 0x20E0 +#define GLX_BACK_RIGHT_EXT 0x20E1 +#define GLX_AUX0_EXT 0x20E2 +#define GLX_AUX1_EXT 0x20E3 +#define GLX_AUX2_EXT 0x20E4 +#define GLX_AUX3_EXT 0x20E5 +#define GLX_AUX4_EXT 0x20E6 +#define GLX_AUX5_EXT 0x20E7 +#define GLX_AUX6_EXT 0x20E8 +#define GLX_AUX7_EXT 0x20E9 +#define GLX_AUX8_EXT 0x20EA +#define GLX_AUX9_EXT 0x20EB + +typedef void ( * PFNGLXBINDTEXIMAGEEXTPROC) (Display* display, GLXDrawable drawable, int buffer, const int *attrib_list); +typedef void ( * PFNGLXRELEASETEXIMAGEEXTPROC) (Display* display, GLXDrawable drawable, int buffer); + +#define glXBindTexImageEXT GLXEW_GET_FUN(__glewXBindTexImageEXT) +#define glXReleaseTexImageEXT GLXEW_GET_FUN(__glewXReleaseTexImageEXT) + +#define GLXEW_EXT_texture_from_pixmap GLXEW_GET_VAR(__GLXEW_EXT_texture_from_pixmap) + +#endif /* GLX_EXT_texture_from_pixmap */ + +/* -------------------------- GLX_EXT_visual_info -------------------------- */ + +#ifndef GLX_EXT_visual_info +#define GLX_EXT_visual_info 1 + +#define GLX_X_VISUAL_TYPE_EXT 0x22 +#define GLX_TRANSPARENT_TYPE_EXT 0x23 +#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24 +#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25 +#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26 +#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27 +#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28 +#define GLX_NONE_EXT 0x8000 +#define GLX_TRUE_COLOR_EXT 0x8002 +#define GLX_DIRECT_COLOR_EXT 0x8003 +#define GLX_PSEUDO_COLOR_EXT 0x8004 +#define GLX_STATIC_COLOR_EXT 0x8005 +#define GLX_GRAY_SCALE_EXT 0x8006 +#define GLX_STATIC_GRAY_EXT 0x8007 +#define GLX_TRANSPARENT_RGB_EXT 0x8008 +#define GLX_TRANSPARENT_INDEX_EXT 0x8009 + +#define GLXEW_EXT_visual_info GLXEW_GET_VAR(__GLXEW_EXT_visual_info) + +#endif /* GLX_EXT_visual_info */ + +/* ------------------------- GLX_EXT_visual_rating ------------------------- */ + +#ifndef GLX_EXT_visual_rating +#define GLX_EXT_visual_rating 1 + +#define GLX_VISUAL_CAVEAT_EXT 0x20 +#define GLX_SLOW_VISUAL_EXT 0x8001 +#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D + +#define GLXEW_EXT_visual_rating GLXEW_GET_VAR(__GLXEW_EXT_visual_rating) + +#endif /* GLX_EXT_visual_rating */ + +/* -------------------------- GLX_INTEL_swap_event ------------------------- */ + +#ifndef GLX_INTEL_swap_event +#define GLX_INTEL_swap_event 1 + +#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180 +#define GLX_COPY_COMPLETE_INTEL 0x8181 +#define GLX_FLIP_COMPLETE_INTEL 0x8182 +#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000 + +#define GLXEW_INTEL_swap_event GLXEW_GET_VAR(__GLXEW_INTEL_swap_event) + +#endif /* GLX_INTEL_swap_event */ + +/* -------------------------- GLX_MESA_agp_offset -------------------------- */ + +#ifndef GLX_MESA_agp_offset +#define GLX_MESA_agp_offset 1 + +typedef unsigned int ( * PFNGLXGETAGPOFFSETMESAPROC) (const void* pointer); + +#define glXGetAGPOffsetMESA GLXEW_GET_FUN(__glewXGetAGPOffsetMESA) + +#define GLXEW_MESA_agp_offset GLXEW_GET_VAR(__GLXEW_MESA_agp_offset) + +#endif /* GLX_MESA_agp_offset */ + +/* ------------------------ GLX_MESA_copy_sub_buffer ----------------------- */ + +#ifndef GLX_MESA_copy_sub_buffer +#define GLX_MESA_copy_sub_buffer 1 + +typedef void ( * PFNGLXCOPYSUBBUFFERMESAPROC) (Display* dpy, GLXDrawable drawable, int x, int y, int width, int height); + +#define glXCopySubBufferMESA GLXEW_GET_FUN(__glewXCopySubBufferMESA) + +#define GLXEW_MESA_copy_sub_buffer GLXEW_GET_VAR(__GLXEW_MESA_copy_sub_buffer) + +#endif /* GLX_MESA_copy_sub_buffer */ + +/* ------------------------ GLX_MESA_pixmap_colormap ----------------------- */ + +#ifndef GLX_MESA_pixmap_colormap +#define GLX_MESA_pixmap_colormap 1 + +typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPMESAPROC) (Display* dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap); + +#define glXCreateGLXPixmapMESA GLXEW_GET_FUN(__glewXCreateGLXPixmapMESA) + +#define GLXEW_MESA_pixmap_colormap GLXEW_GET_VAR(__GLXEW_MESA_pixmap_colormap) + +#endif /* GLX_MESA_pixmap_colormap */ + +/* ------------------------ GLX_MESA_release_buffers ----------------------- */ + +#ifndef GLX_MESA_release_buffers +#define GLX_MESA_release_buffers 1 + +typedef Bool ( * PFNGLXRELEASEBUFFERSMESAPROC) (Display* dpy, GLXDrawable d); + +#define glXReleaseBuffersMESA GLXEW_GET_FUN(__glewXReleaseBuffersMESA) + +#define GLXEW_MESA_release_buffers GLXEW_GET_VAR(__GLXEW_MESA_release_buffers) + +#endif /* GLX_MESA_release_buffers */ + +/* ------------------------- GLX_MESA_set_3dfx_mode ------------------------ */ + +#ifndef GLX_MESA_set_3dfx_mode +#define GLX_MESA_set_3dfx_mode 1 + +#define GLX_3DFX_WINDOW_MODE_MESA 0x1 +#define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2 + +typedef GLboolean ( * PFNGLXSET3DFXMODEMESAPROC) (GLint mode); + +#define glXSet3DfxModeMESA GLXEW_GET_FUN(__glewXSet3DfxModeMESA) + +#define GLXEW_MESA_set_3dfx_mode GLXEW_GET_VAR(__GLXEW_MESA_set_3dfx_mode) + +#endif /* GLX_MESA_set_3dfx_mode */ + +/* ------------------------- GLX_MESA_swap_control ------------------------- */ + +#ifndef GLX_MESA_swap_control +#define GLX_MESA_swap_control 1 + +typedef int ( * PFNGLXGETSWAPINTERVALMESAPROC) (void); +typedef int ( * PFNGLXSWAPINTERVALMESAPROC) (unsigned int interval); + +#define glXGetSwapIntervalMESA GLXEW_GET_FUN(__glewXGetSwapIntervalMESA) +#define glXSwapIntervalMESA GLXEW_GET_FUN(__glewXSwapIntervalMESA) + +#define GLXEW_MESA_swap_control GLXEW_GET_VAR(__GLXEW_MESA_swap_control) + +#endif /* GLX_MESA_swap_control */ + +/* --------------------------- GLX_NV_copy_image --------------------------- */ + +#ifndef GLX_NV_copy_image +#define GLX_NV_copy_image 1 + +typedef void ( * PFNGLXCOPYIMAGESUBDATANVPROC) (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); + +#define glXCopyImageSubDataNV GLXEW_GET_FUN(__glewXCopyImageSubDataNV) + +#define GLXEW_NV_copy_image GLXEW_GET_VAR(__GLXEW_NV_copy_image) + +#endif /* GLX_NV_copy_image */ + +/* -------------------------- GLX_NV_float_buffer -------------------------- */ + +#ifndef GLX_NV_float_buffer +#define GLX_NV_float_buffer 1 + +#define GLX_FLOAT_COMPONENTS_NV 0x20B0 + +#define GLXEW_NV_float_buffer GLXEW_GET_VAR(__GLXEW_NV_float_buffer) + +#endif /* GLX_NV_float_buffer */ + +/* ---------------------- GLX_NV_multisample_coverage ---------------------- */ + +#ifndef GLX_NV_multisample_coverage +#define GLX_NV_multisample_coverage 1 + +#define GLX_COLOR_SAMPLES_NV 0x20B3 +#define GLX_COVERAGE_SAMPLES_NV 100001 + +#define GLXEW_NV_multisample_coverage GLXEW_GET_VAR(__GLXEW_NV_multisample_coverage) + +#endif /* GLX_NV_multisample_coverage */ + +/* -------------------------- GLX_NV_present_video ------------------------- */ + +#ifndef GLX_NV_present_video +#define GLX_NV_present_video 1 + +#define GLX_NUM_VIDEO_SLOTS_NV 0x20F0 + +typedef int ( * PFNGLXBINDVIDEODEVICENVPROC) (Display* dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list); +typedef unsigned int* ( * PFNGLXENUMERATEVIDEODEVICESNVPROC) (Display *dpy, int screen, int *nelements); + +#define glXBindVideoDeviceNV GLXEW_GET_FUN(__glewXBindVideoDeviceNV) +#define glXEnumerateVideoDevicesNV GLXEW_GET_FUN(__glewXEnumerateVideoDevicesNV) + +#define GLXEW_NV_present_video GLXEW_GET_VAR(__GLXEW_NV_present_video) + +#endif /* GLX_NV_present_video */ + +/* --------------------------- GLX_NV_swap_group --------------------------- */ + +#ifndef GLX_NV_swap_group +#define GLX_NV_swap_group 1 + +typedef Bool ( * PFNGLXBINDSWAPBARRIERNVPROC) (Display* dpy, GLuint group, GLuint barrier); +typedef Bool ( * PFNGLXJOINSWAPGROUPNVPROC) (Display* dpy, GLXDrawable drawable, GLuint group); +typedef Bool ( * PFNGLXQUERYFRAMECOUNTNVPROC) (Display* dpy, int screen, GLuint *count); +typedef Bool ( * PFNGLXQUERYMAXSWAPGROUPSNVPROC) (Display* dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers); +typedef Bool ( * PFNGLXQUERYSWAPGROUPNVPROC) (Display* dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier); +typedef Bool ( * PFNGLXRESETFRAMECOUNTNVPROC) (Display* dpy, int screen); + +#define glXBindSwapBarrierNV GLXEW_GET_FUN(__glewXBindSwapBarrierNV) +#define glXJoinSwapGroupNV GLXEW_GET_FUN(__glewXJoinSwapGroupNV) +#define glXQueryFrameCountNV GLXEW_GET_FUN(__glewXQueryFrameCountNV) +#define glXQueryMaxSwapGroupsNV GLXEW_GET_FUN(__glewXQueryMaxSwapGroupsNV) +#define glXQuerySwapGroupNV GLXEW_GET_FUN(__glewXQuerySwapGroupNV) +#define glXResetFrameCountNV GLXEW_GET_FUN(__glewXResetFrameCountNV) + +#define GLXEW_NV_swap_group GLXEW_GET_VAR(__GLXEW_NV_swap_group) + +#endif /* GLX_NV_swap_group */ + +/* ----------------------- GLX_NV_vertex_array_range ----------------------- */ + +#ifndef GLX_NV_vertex_array_range +#define GLX_NV_vertex_array_range 1 + +typedef void * ( * PFNGLXALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority); +typedef void ( * PFNGLXFREEMEMORYNVPROC) (void *pointer); + +#define glXAllocateMemoryNV GLXEW_GET_FUN(__glewXAllocateMemoryNV) +#define glXFreeMemoryNV GLXEW_GET_FUN(__glewXFreeMemoryNV) + +#define GLXEW_NV_vertex_array_range GLXEW_GET_VAR(__GLXEW_NV_vertex_array_range) + +#endif /* GLX_NV_vertex_array_range */ + +/* -------------------------- GLX_NV_video_capture ------------------------- */ + +#ifndef GLX_NV_video_capture +#define GLX_NV_video_capture 1 + +#define GLX_DEVICE_ID_NV 0x20CD +#define GLX_UNIQUE_ID_NV 0x20CE +#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF + +typedef XID GLXVideoCaptureDeviceNV; + +typedef int ( * PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) (Display* dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device); +typedef GLXVideoCaptureDeviceNV * ( * PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) (Display* dpy, int screen, int *nelements); +typedef void ( * PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device); +typedef int ( * PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value); +typedef void ( * PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device); + +#define glXBindVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXBindVideoCaptureDeviceNV) +#define glXEnumerateVideoCaptureDevicesNV GLXEW_GET_FUN(__glewXEnumerateVideoCaptureDevicesNV) +#define glXLockVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXLockVideoCaptureDeviceNV) +#define glXQueryVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXQueryVideoCaptureDeviceNV) +#define glXReleaseVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXReleaseVideoCaptureDeviceNV) + +#define GLXEW_NV_video_capture GLXEW_GET_VAR(__GLXEW_NV_video_capture) + +#endif /* GLX_NV_video_capture */ + +/* -------------------------- GLX_NV_video_output -------------------------- */ + +#ifndef GLX_NV_video_output +#define GLX_NV_video_output 1 + +#define GLX_VIDEO_OUT_COLOR_NV 0x20C3 +#define GLX_VIDEO_OUT_ALPHA_NV 0x20C4 +#define GLX_VIDEO_OUT_DEPTH_NV 0x20C5 +#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 +#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 +#define GLX_VIDEO_OUT_FRAME_NV 0x20C8 +#define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9 +#define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA +#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB +#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC + +typedef int ( * PFNGLXBINDVIDEOIMAGENVPROC) (Display* dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer); +typedef int ( * PFNGLXGETVIDEODEVICENVPROC) (Display* dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice); +typedef int ( * PFNGLXGETVIDEOINFONVPROC) (Display* dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +typedef int ( * PFNGLXRELEASEVIDEODEVICENVPROC) (Display* dpy, int screen, GLXVideoDeviceNV VideoDevice); +typedef int ( * PFNGLXRELEASEVIDEOIMAGENVPROC) (Display* dpy, GLXPbuffer pbuf); +typedef int ( * PFNGLXSENDPBUFFERTOVIDEONVPROC) (Display* dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock); + +#define glXBindVideoImageNV GLXEW_GET_FUN(__glewXBindVideoImageNV) +#define glXGetVideoDeviceNV GLXEW_GET_FUN(__glewXGetVideoDeviceNV) +#define glXGetVideoInfoNV GLXEW_GET_FUN(__glewXGetVideoInfoNV) +#define glXReleaseVideoDeviceNV GLXEW_GET_FUN(__glewXReleaseVideoDeviceNV) +#define glXReleaseVideoImageNV GLXEW_GET_FUN(__glewXReleaseVideoImageNV) +#define glXSendPbufferToVideoNV GLXEW_GET_FUN(__glewXSendPbufferToVideoNV) + +#define GLXEW_NV_video_output GLXEW_GET_VAR(__GLXEW_NV_video_output) + +#endif /* GLX_NV_video_output */ + +/* -------------------------- GLX_OML_swap_method -------------------------- */ + +#ifndef GLX_OML_swap_method +#define GLX_OML_swap_method 1 + +#define GLX_SWAP_METHOD_OML 0x8060 +#define GLX_SWAP_EXCHANGE_OML 0x8061 +#define GLX_SWAP_COPY_OML 0x8062 +#define GLX_SWAP_UNDEFINED_OML 0x8063 + +#define GLXEW_OML_swap_method GLXEW_GET_VAR(__GLXEW_OML_swap_method) + +#endif /* GLX_OML_swap_method */ + +/* -------------------------- GLX_OML_sync_control ------------------------- */ + +#ifndef GLX_OML_sync_control +#define GLX_OML_sync_control 1 + +typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display* dpy, GLXDrawable drawable, int32_t* numerator, int32_t* denominator); +typedef Bool ( * PFNGLXGETSYNCVALUESOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t* ust, int64_t* msc, int64_t* sbc); +typedef int64_t ( * PFNGLXSWAPBUFFERSMSCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder); +typedef Bool ( * PFNGLXWAITFORMSCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t* ust, int64_t* msc, int64_t* sbc); +typedef Bool ( * PFNGLXWAITFORSBCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_sbc, int64_t* ust, int64_t* msc, int64_t* sbc); + +#define glXGetMscRateOML GLXEW_GET_FUN(__glewXGetMscRateOML) +#define glXGetSyncValuesOML GLXEW_GET_FUN(__glewXGetSyncValuesOML) +#define glXSwapBuffersMscOML GLXEW_GET_FUN(__glewXSwapBuffersMscOML) +#define glXWaitForMscOML GLXEW_GET_FUN(__glewXWaitForMscOML) +#define glXWaitForSbcOML GLXEW_GET_FUN(__glewXWaitForSbcOML) + +#define GLXEW_OML_sync_control GLXEW_GET_VAR(__GLXEW_OML_sync_control) + +#endif /* GLX_OML_sync_control */ + +/* ------------------------ GLX_SGIS_blended_overlay ----------------------- */ + +#ifndef GLX_SGIS_blended_overlay +#define GLX_SGIS_blended_overlay 1 + +#define GLX_BLENDED_RGBA_SGIS 0x8025 + +#define GLXEW_SGIS_blended_overlay GLXEW_GET_VAR(__GLXEW_SGIS_blended_overlay) + +#endif /* GLX_SGIS_blended_overlay */ + +/* -------------------------- GLX_SGIS_color_range ------------------------- */ + +#ifndef GLX_SGIS_color_range +#define GLX_SGIS_color_range 1 + +#define GLX_MIN_RED_SGIS 0 +#define GLX_MAX_GREEN_SGIS 0 +#define GLX_MIN_BLUE_SGIS 0 +#define GLX_MAX_ALPHA_SGIS 0 +#define GLX_MIN_GREEN_SGIS 0 +#define GLX_MIN_ALPHA_SGIS 0 +#define GLX_MAX_RED_SGIS 0 +#define GLX_EXTENDED_RANGE_SGIS 0 +#define GLX_MAX_BLUE_SGIS 0 + +#define GLXEW_SGIS_color_range GLXEW_GET_VAR(__GLXEW_SGIS_color_range) + +#endif /* GLX_SGIS_color_range */ + +/* -------------------------- GLX_SGIS_multisample ------------------------- */ + +#ifndef GLX_SGIS_multisample +#define GLX_SGIS_multisample 1 + +#define GLX_SAMPLE_BUFFERS_SGIS 100000 +#define GLX_SAMPLES_SGIS 100001 + +#define GLXEW_SGIS_multisample GLXEW_GET_VAR(__GLXEW_SGIS_multisample) + +#endif /* GLX_SGIS_multisample */ + +/* ---------------------- GLX_SGIS_shared_multisample ---------------------- */ + +#ifndef GLX_SGIS_shared_multisample +#define GLX_SGIS_shared_multisample 1 + +#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026 +#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027 + +#define GLXEW_SGIS_shared_multisample GLXEW_GET_VAR(__GLXEW_SGIS_shared_multisample) + +#endif /* GLX_SGIS_shared_multisample */ + +/* --------------------------- GLX_SGIX_fbconfig --------------------------- */ + +#ifndef GLX_SGIX_fbconfig +#define GLX_SGIX_fbconfig 1 + +#define GLX_WINDOW_BIT_SGIX 0x00000001 +#define GLX_RGBA_BIT_SGIX 0x00000001 +#define GLX_PIXMAP_BIT_SGIX 0x00000002 +#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002 +#define GLX_SCREEN_EXT 0x800C +#define GLX_DRAWABLE_TYPE_SGIX 0x8010 +#define GLX_RENDER_TYPE_SGIX 0x8011 +#define GLX_X_RENDERABLE_SGIX 0x8012 +#define GLX_FBCONFIG_ID_SGIX 0x8013 +#define GLX_RGBA_TYPE_SGIX 0x8014 +#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015 + +typedef XID GLXFBConfigIDSGIX; +typedef struct __GLXFBConfigRec *GLXFBConfigSGIX; + +typedef GLXFBConfigSGIX* ( * PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements); +typedef GLXContext ( * PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display* dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct); +typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) (Display* dpy, GLXFBConfig config, Pixmap pixmap); +typedef int ( * PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display* dpy, GLXFBConfigSGIX config, int attribute, int *value); +typedef GLXFBConfigSGIX ( * PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) (Display* dpy, XVisualInfo *vis); +typedef XVisualInfo* ( * PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfig config); + +#define glXChooseFBConfigSGIX GLXEW_GET_FUN(__glewXChooseFBConfigSGIX) +#define glXCreateContextWithConfigSGIX GLXEW_GET_FUN(__glewXCreateContextWithConfigSGIX) +#define glXCreateGLXPixmapWithConfigSGIX GLXEW_GET_FUN(__glewXCreateGLXPixmapWithConfigSGIX) +#define glXGetFBConfigAttribSGIX GLXEW_GET_FUN(__glewXGetFBConfigAttribSGIX) +#define glXGetFBConfigFromVisualSGIX GLXEW_GET_FUN(__glewXGetFBConfigFromVisualSGIX) +#define glXGetVisualFromFBConfigSGIX GLXEW_GET_FUN(__glewXGetVisualFromFBConfigSGIX) + +#define GLXEW_SGIX_fbconfig GLXEW_GET_VAR(__GLXEW_SGIX_fbconfig) + +#endif /* GLX_SGIX_fbconfig */ + +/* --------------------------- GLX_SGIX_hyperpipe -------------------------- */ + +#ifndef GLX_SGIX_hyperpipe +#define GLX_SGIX_hyperpipe 1 + +#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX 0x00000001 +#define GLX_PIPE_RECT_SGIX 0x00000001 +#define GLX_PIPE_RECT_LIMITS_SGIX 0x00000002 +#define GLX_HYPERPIPE_RENDER_PIPE_SGIX 0x00000002 +#define GLX_HYPERPIPE_STEREO_SGIX 0x00000003 +#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX 0x00000004 +#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80 +#define GLX_BAD_HYPERPIPE_CONFIG_SGIX 91 +#define GLX_BAD_HYPERPIPE_SGIX 92 +#define GLX_HYPERPIPE_ID_SGIX 0x8030 + +typedef struct { + char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; + int networkId; +} GLXHyperpipeNetworkSGIX; +typedef struct { + char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; + int XOrigin; + int YOrigin; + int maxHeight; + int maxWidth; +} GLXPipeRectLimits; +typedef struct { + char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; + int channel; + unsigned int participationType; + int timeSlice; +} GLXHyperpipeConfigSGIX; +typedef struct { + char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; + int srcXOrigin; + int srcYOrigin; + int srcWidth; + int srcHeight; + int destXOrigin; + int destYOrigin; + int destWidth; + int destHeight; +} GLXPipeRect; + +typedef int ( * PFNGLXBINDHYPERPIPESGIXPROC) (Display *dpy, int hpId); +typedef int ( * PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId); +typedef int ( * PFNGLXHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList); +typedef int ( * PFNGLXHYPERPIPECONFIGSGIXPROC) (Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId); +typedef int ( * PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList); +typedef int ( * PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList); +typedef GLXHyperpipeConfigSGIX * ( * PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId, int *npipes); +typedef GLXHyperpipeNetworkSGIX * ( * PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) (Display *dpy, int *npipes); + +#define glXBindHyperpipeSGIX GLXEW_GET_FUN(__glewXBindHyperpipeSGIX) +#define glXDestroyHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXDestroyHyperpipeConfigSGIX) +#define glXHyperpipeAttribSGIX GLXEW_GET_FUN(__glewXHyperpipeAttribSGIX) +#define glXHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXHyperpipeConfigSGIX) +#define glXQueryHyperpipeAttribSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeAttribSGIX) +#define glXQueryHyperpipeBestAttribSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeBestAttribSGIX) +#define glXQueryHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeConfigSGIX) +#define glXQueryHyperpipeNetworkSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeNetworkSGIX) + +#define GLXEW_SGIX_hyperpipe GLXEW_GET_VAR(__GLXEW_SGIX_hyperpipe) + +#endif /* GLX_SGIX_hyperpipe */ + +/* ---------------------------- GLX_SGIX_pbuffer --------------------------- */ + +#ifndef GLX_SGIX_pbuffer +#define GLX_SGIX_pbuffer 1 + +#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001 +#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002 +#define GLX_PBUFFER_BIT_SGIX 0x00000004 +#define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004 +#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008 +#define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010 +#define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020 +#define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040 +#define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080 +#define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100 +#define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016 +#define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017 +#define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018 +#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019 +#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A +#define GLX_PRESERVED_CONTENTS_SGIX 0x801B +#define GLX_LARGEST_PBUFFER_SGIX 0x801C +#define GLX_WIDTH_SGIX 0x801D +#define GLX_HEIGHT_SGIX 0x801E +#define GLX_EVENT_MASK_SGIX 0x801F +#define GLX_DAMAGED_SGIX 0x8020 +#define GLX_SAVED_SGIX 0x8021 +#define GLX_WINDOW_SGIX 0x8022 +#define GLX_PBUFFER_SGIX 0x8023 +#define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000 + +typedef XID GLXPbufferSGIX; +typedef struct { int type; unsigned long serial; Bool send_event; Display *display; GLXDrawable drawable; int event_type; int draw_type; unsigned int mask; int x, y; int width, height; int count; } GLXBufferClobberEventSGIX; + +typedef GLXPbuffer ( * PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display* dpy, GLXFBConfig config, unsigned int width, unsigned int height, int *attrib_list); +typedef void ( * PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display* dpy, GLXPbuffer pbuf); +typedef void ( * PFNGLXGETSELECTEDEVENTSGIXPROC) (Display* dpy, GLXDrawable drawable, unsigned long *mask); +typedef void ( * PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display* dpy, GLXPbuffer pbuf, int attribute, unsigned int *value); +typedef void ( * PFNGLXSELECTEVENTSGIXPROC) (Display* dpy, GLXDrawable drawable, unsigned long mask); + +#define glXCreateGLXPbufferSGIX GLXEW_GET_FUN(__glewXCreateGLXPbufferSGIX) +#define glXDestroyGLXPbufferSGIX GLXEW_GET_FUN(__glewXDestroyGLXPbufferSGIX) +#define glXGetSelectedEventSGIX GLXEW_GET_FUN(__glewXGetSelectedEventSGIX) +#define glXQueryGLXPbufferSGIX GLXEW_GET_FUN(__glewXQueryGLXPbufferSGIX) +#define glXSelectEventSGIX GLXEW_GET_FUN(__glewXSelectEventSGIX) + +#define GLXEW_SGIX_pbuffer GLXEW_GET_VAR(__GLXEW_SGIX_pbuffer) + +#endif /* GLX_SGIX_pbuffer */ + +/* ------------------------- GLX_SGIX_swap_barrier ------------------------- */ + +#ifndef GLX_SGIX_swap_barrier +#define GLX_SGIX_swap_barrier 1 + +typedef void ( * PFNGLXBINDSWAPBARRIERSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier); +typedef Bool ( * PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) (Display *dpy, int screen, int *max); + +#define glXBindSwapBarrierSGIX GLXEW_GET_FUN(__glewXBindSwapBarrierSGIX) +#define glXQueryMaxSwapBarriersSGIX GLXEW_GET_FUN(__glewXQueryMaxSwapBarriersSGIX) + +#define GLXEW_SGIX_swap_barrier GLXEW_GET_VAR(__GLXEW_SGIX_swap_barrier) + +#endif /* GLX_SGIX_swap_barrier */ + +/* -------------------------- GLX_SGIX_swap_group -------------------------- */ + +#ifndef GLX_SGIX_swap_group +#define GLX_SGIX_swap_group 1 + +typedef void ( * PFNGLXJOINSWAPGROUPSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member); + +#define glXJoinSwapGroupSGIX GLXEW_GET_FUN(__glewXJoinSwapGroupSGIX) + +#define GLXEW_SGIX_swap_group GLXEW_GET_VAR(__GLXEW_SGIX_swap_group) + +#endif /* GLX_SGIX_swap_group */ + +/* ------------------------- GLX_SGIX_video_resize ------------------------- */ + +#ifndef GLX_SGIX_video_resize +#define GLX_SGIX_video_resize 1 + +#define GLX_SYNC_FRAME_SGIX 0x00000000 +#define GLX_SYNC_SWAP_SGIX 0x00000001 + +typedef int ( * PFNGLXBINDCHANNELTOWINDOWSGIXPROC) (Display* display, int screen, int channel, Window window); +typedef int ( * PFNGLXCHANNELRECTSGIXPROC) (Display* display, int screen, int channel, int x, int y, int w, int h); +typedef int ( * PFNGLXCHANNELRECTSYNCSGIXPROC) (Display* display, int screen, int channel, GLenum synctype); +typedef int ( * PFNGLXQUERYCHANNELDELTASSGIXPROC) (Display* display, int screen, int channel, int *x, int *y, int *w, int *h); +typedef int ( * PFNGLXQUERYCHANNELRECTSGIXPROC) (Display* display, int screen, int channel, int *dx, int *dy, int *dw, int *dh); + +#define glXBindChannelToWindowSGIX GLXEW_GET_FUN(__glewXBindChannelToWindowSGIX) +#define glXChannelRectSGIX GLXEW_GET_FUN(__glewXChannelRectSGIX) +#define glXChannelRectSyncSGIX GLXEW_GET_FUN(__glewXChannelRectSyncSGIX) +#define glXQueryChannelDeltasSGIX GLXEW_GET_FUN(__glewXQueryChannelDeltasSGIX) +#define glXQueryChannelRectSGIX GLXEW_GET_FUN(__glewXQueryChannelRectSGIX) + +#define GLXEW_SGIX_video_resize GLXEW_GET_VAR(__GLXEW_SGIX_video_resize) + +#endif /* GLX_SGIX_video_resize */ + +/* ---------------------- GLX_SGIX_visual_select_group --------------------- */ + +#ifndef GLX_SGIX_visual_select_group +#define GLX_SGIX_visual_select_group 1 + +#define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028 + +#define GLXEW_SGIX_visual_select_group GLXEW_GET_VAR(__GLXEW_SGIX_visual_select_group) + +#endif /* GLX_SGIX_visual_select_group */ + +/* ---------------------------- GLX_SGI_cushion ---------------------------- */ + +#ifndef GLX_SGI_cushion +#define GLX_SGI_cushion 1 + +typedef void ( * PFNGLXCUSHIONSGIPROC) (Display* dpy, Window window, float cushion); + +#define glXCushionSGI GLXEW_GET_FUN(__glewXCushionSGI) + +#define GLXEW_SGI_cushion GLXEW_GET_VAR(__GLXEW_SGI_cushion) + +#endif /* GLX_SGI_cushion */ + +/* ----------------------- GLX_SGI_make_current_read ----------------------- */ + +#ifndef GLX_SGI_make_current_read +#define GLX_SGI_make_current_read 1 + +typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLESGIPROC) (void); +typedef Bool ( * PFNGLXMAKECURRENTREADSGIPROC) (Display* dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx); + +#define glXGetCurrentReadDrawableSGI GLXEW_GET_FUN(__glewXGetCurrentReadDrawableSGI) +#define glXMakeCurrentReadSGI GLXEW_GET_FUN(__glewXMakeCurrentReadSGI) + +#define GLXEW_SGI_make_current_read GLXEW_GET_VAR(__GLXEW_SGI_make_current_read) + +#endif /* GLX_SGI_make_current_read */ + +/* -------------------------- GLX_SGI_swap_control ------------------------- */ + +#ifndef GLX_SGI_swap_control +#define GLX_SGI_swap_control 1 + +typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval); + +#define glXSwapIntervalSGI GLXEW_GET_FUN(__glewXSwapIntervalSGI) + +#define GLXEW_SGI_swap_control GLXEW_GET_VAR(__GLXEW_SGI_swap_control) + +#endif /* GLX_SGI_swap_control */ + +/* --------------------------- GLX_SGI_video_sync -------------------------- */ + +#ifndef GLX_SGI_video_sync +#define GLX_SGI_video_sync 1 + +typedef int ( * PFNGLXGETVIDEOSYNCSGIPROC) (unsigned int* count); +typedef int ( * PFNGLXWAITVIDEOSYNCSGIPROC) (int divisor, int remainder, unsigned int* count); + +#define glXGetVideoSyncSGI GLXEW_GET_FUN(__glewXGetVideoSyncSGI) +#define glXWaitVideoSyncSGI GLXEW_GET_FUN(__glewXWaitVideoSyncSGI) + +#define GLXEW_SGI_video_sync GLXEW_GET_VAR(__GLXEW_SGI_video_sync) + +#endif /* GLX_SGI_video_sync */ + +/* --------------------- GLX_SUN_get_transparent_index --------------------- */ + +#ifndef GLX_SUN_get_transparent_index +#define GLX_SUN_get_transparent_index 1 + +typedef Status ( * PFNGLXGETTRANSPARENTINDEXSUNPROC) (Display* dpy, Window overlay, Window underlay, unsigned long *pTransparentIndex); + +#define glXGetTransparentIndexSUN GLXEW_GET_FUN(__glewXGetTransparentIndexSUN) + +#define GLXEW_SUN_get_transparent_index GLXEW_GET_VAR(__GLXEW_SUN_get_transparent_index) + +#endif /* GLX_SUN_get_transparent_index */ + +/* -------------------------- GLX_SUN_video_resize ------------------------- */ + +#ifndef GLX_SUN_video_resize +#define GLX_SUN_video_resize 1 + +#define GLX_VIDEO_RESIZE_SUN 0x8171 +#define GL_VIDEO_RESIZE_COMPENSATION_SUN 0x85CD + +typedef int ( * PFNGLXGETVIDEORESIZESUNPROC) (Display* display, GLXDrawable window, float* factor); +typedef int ( * PFNGLXVIDEORESIZESUNPROC) (Display* display, GLXDrawable window, float factor); + +#define glXGetVideoResizeSUN GLXEW_GET_FUN(__glewXGetVideoResizeSUN) +#define glXVideoResizeSUN GLXEW_GET_FUN(__glewXVideoResizeSUN) + +#define GLXEW_SUN_video_resize GLXEW_GET_VAR(__GLXEW_SUN_video_resize) + +#endif /* GLX_SUN_video_resize */ + +/* ------------------------------------------------------------------------- */ + +#ifdef GLEW_MX +#define GLXEW_EXPORT +#else +#define GLXEW_EXPORT extern +#endif /* GLEW_MX */ + +extern PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay; + +extern PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig; +extern PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext; +extern PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer; +extern PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap; +extern PFNGLXCREATEWINDOWPROC __glewXCreateWindow; +extern PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer; +extern PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap; +extern PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow; +extern PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable; +extern PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib; +extern PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs; +extern PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent; +extern PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig; +extern PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent; +extern PFNGLXQUERYCONTEXTPROC __glewXQueryContext; +extern PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable; +extern PFNGLXSELECTEVENTPROC __glewXSelectEvent; + +extern PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB; + +extern PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI; +extern PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI; +extern PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI; + +extern PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT; +extern PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT; +extern PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT; +extern PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT; + +extern PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT; + +extern PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT; +extern PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT; + +extern PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA; + +extern PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA; + +extern PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA; + +extern PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA; + +extern PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA; + +extern PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA; +extern PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA; + +extern PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV; + +extern PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV; +extern PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV; + +extern PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV; +extern PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV; +extern PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV; +extern PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV; +extern PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV; +extern PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV; + +extern PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV; +extern PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV; + +extern PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV; +extern PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV; +extern PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV; +extern PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV; +extern PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV; + +extern PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV; +extern PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV; +extern PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV; +extern PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV; +extern PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV; +extern PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV; + +extern PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML; +extern PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML; +extern PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML; +extern PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML; +extern PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML; + +extern PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX; +extern PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX; +extern PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX; +extern PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX; +extern PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX; +extern PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX; + +extern PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX; +extern PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX; +extern PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX; +extern PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX; +extern PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX; +extern PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX; +extern PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX; +extern PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX; + +extern PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX; +extern PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX; +extern PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX; +extern PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX; +extern PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX; + +extern PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX; +extern PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX; + +extern PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX; + +extern PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX; +extern PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX; +extern PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX; +extern PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX; +extern PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX; + +extern PFNGLXCUSHIONSGIPROC __glewXCushionSGI; + +extern PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI; +extern PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI; + +extern PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI; + +extern PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI; +extern PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI; + +extern PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN; + +extern PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN; +extern PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN; + +#if defined(GLEW_MX) +struct GLXEWContextStruct +{ +#endif /* GLEW_MX */ + +GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_0; +GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_1; +GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_2; +GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_3; +GLXEW_EXPORT GLboolean __GLXEW_VERSION_1_4; +GLXEW_EXPORT GLboolean __GLXEW_3DFX_multisample; +GLXEW_EXPORT GLboolean __GLXEW_AMD_gpu_association; +GLXEW_EXPORT GLboolean __GLXEW_ARB_create_context; +GLXEW_EXPORT GLboolean __GLXEW_ARB_create_context_profile; +GLXEW_EXPORT GLboolean __GLXEW_ARB_create_context_robustness; +GLXEW_EXPORT GLboolean __GLXEW_ARB_fbconfig_float; +GLXEW_EXPORT GLboolean __GLXEW_ARB_framebuffer_sRGB; +GLXEW_EXPORT GLboolean __GLXEW_ARB_get_proc_address; +GLXEW_EXPORT GLboolean __GLXEW_ARB_multisample; +GLXEW_EXPORT GLboolean __GLXEW_ARB_vertex_buffer_object; +GLXEW_EXPORT GLboolean __GLXEW_ATI_pixel_format_float; +GLXEW_EXPORT GLboolean __GLXEW_ATI_render_texture; +GLXEW_EXPORT GLboolean __GLXEW_EXT_create_context_es2_profile; +GLXEW_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float; +GLXEW_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB; +GLXEW_EXPORT GLboolean __GLXEW_EXT_import_context; +GLXEW_EXPORT GLboolean __GLXEW_EXT_scene_marker; +GLXEW_EXPORT GLboolean __GLXEW_EXT_swap_control; +GLXEW_EXPORT GLboolean __GLXEW_EXT_texture_from_pixmap; +GLXEW_EXPORT GLboolean __GLXEW_EXT_visual_info; +GLXEW_EXPORT GLboolean __GLXEW_EXT_visual_rating; +GLXEW_EXPORT GLboolean __GLXEW_INTEL_swap_event; +GLXEW_EXPORT GLboolean __GLXEW_MESA_agp_offset; +GLXEW_EXPORT GLboolean __GLXEW_MESA_copy_sub_buffer; +GLXEW_EXPORT GLboolean __GLXEW_MESA_pixmap_colormap; +GLXEW_EXPORT GLboolean __GLXEW_MESA_release_buffers; +GLXEW_EXPORT GLboolean __GLXEW_MESA_set_3dfx_mode; +GLXEW_EXPORT GLboolean __GLXEW_MESA_swap_control; +GLXEW_EXPORT GLboolean __GLXEW_NV_copy_image; +GLXEW_EXPORT GLboolean __GLXEW_NV_float_buffer; +GLXEW_EXPORT GLboolean __GLXEW_NV_multisample_coverage; +GLXEW_EXPORT GLboolean __GLXEW_NV_present_video; +GLXEW_EXPORT GLboolean __GLXEW_NV_swap_group; +GLXEW_EXPORT GLboolean __GLXEW_NV_vertex_array_range; +GLXEW_EXPORT GLboolean __GLXEW_NV_video_capture; +GLXEW_EXPORT GLboolean __GLXEW_NV_video_output; +GLXEW_EXPORT GLboolean __GLXEW_OML_swap_method; +GLXEW_EXPORT GLboolean __GLXEW_OML_sync_control; +GLXEW_EXPORT GLboolean __GLXEW_SGIS_blended_overlay; +GLXEW_EXPORT GLboolean __GLXEW_SGIS_color_range; +GLXEW_EXPORT GLboolean __GLXEW_SGIS_multisample; +GLXEW_EXPORT GLboolean __GLXEW_SGIS_shared_multisample; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_fbconfig; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_hyperpipe; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_pbuffer; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_swap_barrier; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_swap_group; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_video_resize; +GLXEW_EXPORT GLboolean __GLXEW_SGIX_visual_select_group; +GLXEW_EXPORT GLboolean __GLXEW_SGI_cushion; +GLXEW_EXPORT GLboolean __GLXEW_SGI_make_current_read; +GLXEW_EXPORT GLboolean __GLXEW_SGI_swap_control; +GLXEW_EXPORT GLboolean __GLXEW_SGI_video_sync; +GLXEW_EXPORT GLboolean __GLXEW_SUN_get_transparent_index; +GLXEW_EXPORT GLboolean __GLXEW_SUN_video_resize; + +#ifdef GLEW_MX +}; /* GLXEWContextStruct */ +#endif /* GLEW_MX */ + +/* ------------------------------------------------------------------------ */ + +#ifdef GLEW_MX + +typedef struct GLXEWContextStruct GLXEWContext; +extern GLenum glxewContextInit (GLXEWContext* ctx); +extern GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name); + +#define glxewInit() glxewContextInit(glxewGetContext()) +#define glxewIsSupported(x) glxewContextIsSupported(glxewGetContext(), x) + +#define GLXEW_GET_VAR(x) (*(const GLboolean*)&(glxewGetContext()->x)) +#define GLXEW_GET_FUN(x) x + +#else /* GLEW_MX */ + +#define GLXEW_GET_VAR(x) (*(const GLboolean*)&x) +#define GLXEW_GET_FUN(x) x + +extern GLboolean glxewIsSupported (const char* name); + +#endif /* GLEW_MX */ + +extern GLboolean glxewGetExtension (const char* name); + +#ifdef __cplusplus +} +#endif + +#endif /* __glxew_h__ */ diff --git a/lib/glew/wglew.h b/lib/glew/wglew.h new file mode 100644 index 0000000..05f054f --- /dev/null +++ b/lib/glew/wglew.h @@ -0,0 +1,1363 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* +** Copyright (c) 2007 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __wglew_h__ +#define __wglew_h__ +#define __WGLEW_H__ + +#ifdef __wglext_h_ +#error wglext.h included before wglew.h +#endif + +#define __wglext_h_ + +#if !defined(WINAPI) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +#include +# undef WIN32_LEAN_AND_MEAN +#endif + +/* + * GLEW_STATIC needs to be set when using the static version. + * GLEW_BUILD is set when building the DLL version. + */ +#ifdef GLEW_STATIC +# define GLEWAPI extern +#else +# ifdef GLEW_BUILD +# define GLEWAPI extern __declspec(dllexport) +# else +# define GLEWAPI extern __declspec(dllimport) +# endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* -------------------------- WGL_3DFX_multisample ------------------------- */ + +#ifndef WGL_3DFX_multisample +#define WGL_3DFX_multisample 1 + +#define WGL_SAMPLE_BUFFERS_3DFX 0x2060 +#define WGL_SAMPLES_3DFX 0x2061 + +#define WGLEW_3DFX_multisample WGLEW_GET_VAR(__WGLEW_3DFX_multisample) + +#endif /* WGL_3DFX_multisample */ + +/* ------------------------- WGL_3DL_stereo_control ------------------------ */ + +#ifndef WGL_3DL_stereo_control +#define WGL_3DL_stereo_control 1 + +#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055 +#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056 +#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057 +#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058 + +typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState); + +#define wglSetStereoEmitterState3DL WGLEW_GET_FUN(__wglewSetStereoEmitterState3DL) + +#define WGLEW_3DL_stereo_control WGLEW_GET_VAR(__WGLEW_3DL_stereo_control) + +#endif /* WGL_3DL_stereo_control */ + +/* ------------------------ WGL_AMD_gpu_association ------------------------ */ + +#ifndef WGL_AMD_gpu_association +#define WGL_AMD_gpu_association 1 + +#define WGL_GPU_VENDOR_AMD 0x1F00 +#define WGL_GPU_RENDERER_STRING_AMD 0x1F01 +#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 +#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 +#define WGL_GPU_RAM_AMD 0x21A3 +#define WGL_GPU_CLOCK_AMD 0x21A4 +#define WGL_GPU_NUM_PIPES_AMD 0x21A5 +#define WGL_GPU_NUM_SIMD_AMD 0x21A6 +#define WGL_GPU_NUM_RB_AMD 0x21A7 +#define WGL_GPU_NUM_SPI_AMD 0x21A8 + +typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int* attribList); +typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc); +typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc); +typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void); +typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT* ids); +typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, INT property, GLenum dataType, UINT size, void* data); +typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc); + +#define wglBlitContextFramebufferAMD WGLEW_GET_FUN(__wglewBlitContextFramebufferAMD) +#define wglCreateAssociatedContextAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAMD) +#define wglCreateAssociatedContextAttribsAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAttribsAMD) +#define wglDeleteAssociatedContextAMD WGLEW_GET_FUN(__wglewDeleteAssociatedContextAMD) +#define wglGetContextGPUIDAMD WGLEW_GET_FUN(__wglewGetContextGPUIDAMD) +#define wglGetCurrentAssociatedContextAMD WGLEW_GET_FUN(__wglewGetCurrentAssociatedContextAMD) +#define wglGetGPUIDsAMD WGLEW_GET_FUN(__wglewGetGPUIDsAMD) +#define wglGetGPUInfoAMD WGLEW_GET_FUN(__wglewGetGPUInfoAMD) +#define wglMakeAssociatedContextCurrentAMD WGLEW_GET_FUN(__wglewMakeAssociatedContextCurrentAMD) + +#define WGLEW_AMD_gpu_association WGLEW_GET_VAR(__WGLEW_AMD_gpu_association) + +#endif /* WGL_AMD_gpu_association */ + +/* ------------------------- WGL_ARB_buffer_region ------------------------- */ + +#ifndef WGL_ARB_buffer_region +#define WGL_ARB_buffer_region 1 + +#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 +#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002 +#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004 +#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008 + +typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); +typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); +typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); + +#define wglCreateBufferRegionARB WGLEW_GET_FUN(__wglewCreateBufferRegionARB) +#define wglDeleteBufferRegionARB WGLEW_GET_FUN(__wglewDeleteBufferRegionARB) +#define wglRestoreBufferRegionARB WGLEW_GET_FUN(__wglewRestoreBufferRegionARB) +#define wglSaveBufferRegionARB WGLEW_GET_FUN(__wglewSaveBufferRegionARB) + +#define WGLEW_ARB_buffer_region WGLEW_GET_VAR(__WGLEW_ARB_buffer_region) + +#endif /* WGL_ARB_buffer_region */ + +/* ------------------------- WGL_ARB_create_context ------------------------ */ + +#ifndef WGL_ARB_create_context +#define WGL_ARB_create_context 1 + +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +#define ERROR_INVALID_VERSION_ARB 0x2095 +#define ERROR_INVALID_PROFILE_ARB 0x2096 + +typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int* attribList); + +#define wglCreateContextAttribsARB WGLEW_GET_FUN(__wglewCreateContextAttribsARB) + +#define WGLEW_ARB_create_context WGLEW_GET_VAR(__WGLEW_ARB_create_context) + +#endif /* WGL_ARB_create_context */ + +/* --------------------- WGL_ARB_create_context_profile -------------------- */ + +#ifndef WGL_ARB_create_context_profile +#define WGL_ARB_create_context_profile 1 + +#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 +#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 +#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 + +#define WGLEW_ARB_create_context_profile WGLEW_GET_VAR(__WGLEW_ARB_create_context_profile) + +#endif /* WGL_ARB_create_context_profile */ + +/* ------------------- WGL_ARB_create_context_robustness ------------------- */ + +#ifndef WGL_ARB_create_context_robustness +#define WGL_ARB_create_context_robustness 1 + +#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 +#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 +#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 +#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261 + +#define WGLEW_ARB_create_context_robustness WGLEW_GET_VAR(__WGLEW_ARB_create_context_robustness) + +#endif /* WGL_ARB_create_context_robustness */ + +/* ----------------------- WGL_ARB_extensions_string ----------------------- */ + +#ifndef WGL_ARB_extensions_string +#define WGL_ARB_extensions_string 1 + +typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); + +#define wglGetExtensionsStringARB WGLEW_GET_FUN(__wglewGetExtensionsStringARB) + +#define WGLEW_ARB_extensions_string WGLEW_GET_VAR(__WGLEW_ARB_extensions_string) + +#endif /* WGL_ARB_extensions_string */ + +/* ------------------------ WGL_ARB_framebuffer_sRGB ----------------------- */ + +#ifndef WGL_ARB_framebuffer_sRGB +#define WGL_ARB_framebuffer_sRGB 1 + +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 + +#define WGLEW_ARB_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_ARB_framebuffer_sRGB) + +#endif /* WGL_ARB_framebuffer_sRGB */ + +/* ----------------------- WGL_ARB_make_current_read ----------------------- */ + +#ifndef WGL_ARB_make_current_read +#define WGL_ARB_make_current_read 1 + +#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043 +#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054 + +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); + +#define wglGetCurrentReadDCARB WGLEW_GET_FUN(__wglewGetCurrentReadDCARB) +#define wglMakeContextCurrentARB WGLEW_GET_FUN(__wglewMakeContextCurrentARB) + +#define WGLEW_ARB_make_current_read WGLEW_GET_VAR(__WGLEW_ARB_make_current_read) + +#endif /* WGL_ARB_make_current_read */ + +/* -------------------------- WGL_ARB_multisample -------------------------- */ + +#ifndef WGL_ARB_multisample +#define WGL_ARB_multisample 1 + +#define WGL_SAMPLE_BUFFERS_ARB 0x2041 +#define WGL_SAMPLES_ARB 0x2042 + +#define WGLEW_ARB_multisample WGLEW_GET_VAR(__WGLEW_ARB_multisample) + +#endif /* WGL_ARB_multisample */ + +/* ---------------------------- WGL_ARB_pbuffer ---------------------------- */ + +#ifndef WGL_ARB_pbuffer +#define WGL_ARB_pbuffer 1 + +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D +#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E +#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 +#define WGL_PBUFFER_LARGEST_ARB 0x2033 +#define WGL_PBUFFER_WIDTH_ARB 0x2034 +#define WGL_PBUFFER_HEIGHT_ARB 0x2035 +#define WGL_PBUFFER_LOST_ARB 0x2036 + +DECLARE_HANDLE(HPBUFFERARB); + +typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int* piValue); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); + +#define wglCreatePbufferARB WGLEW_GET_FUN(__wglewCreatePbufferARB) +#define wglDestroyPbufferARB WGLEW_GET_FUN(__wglewDestroyPbufferARB) +#define wglGetPbufferDCARB WGLEW_GET_FUN(__wglewGetPbufferDCARB) +#define wglQueryPbufferARB WGLEW_GET_FUN(__wglewQueryPbufferARB) +#define wglReleasePbufferDCARB WGLEW_GET_FUN(__wglewReleasePbufferDCARB) + +#define WGLEW_ARB_pbuffer WGLEW_GET_VAR(__WGLEW_ARB_pbuffer) + +#endif /* WGL_ARB_pbuffer */ + +/* -------------------------- WGL_ARB_pixel_format ------------------------- */ + +#ifndef WGL_ARB_pixel_format +#define WGL_ARB_pixel_format 1 + +#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 +#define WGL_DRAW_TO_WINDOW_ARB 0x2001 +#define WGL_DRAW_TO_BITMAP_ARB 0x2002 +#define WGL_ACCELERATION_ARB 0x2003 +#define WGL_NEED_PALETTE_ARB 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 +#define WGL_SWAP_METHOD_ARB 0x2007 +#define WGL_NUMBER_OVERLAYS_ARB 0x2008 +#define WGL_NUMBER_UNDERLAYS_ARB 0x2009 +#define WGL_TRANSPARENT_ARB 0x200A +#define WGL_SHARE_DEPTH_ARB 0x200C +#define WGL_SHARE_STENCIL_ARB 0x200D +#define WGL_SHARE_ACCUM_ARB 0x200E +#define WGL_SUPPORT_GDI_ARB 0x200F +#define WGL_SUPPORT_OPENGL_ARB 0x2010 +#define WGL_DOUBLE_BUFFER_ARB 0x2011 +#define WGL_STEREO_ARB 0x2012 +#define WGL_PIXEL_TYPE_ARB 0x2013 +#define WGL_COLOR_BITS_ARB 0x2014 +#define WGL_RED_BITS_ARB 0x2015 +#define WGL_RED_SHIFT_ARB 0x2016 +#define WGL_GREEN_BITS_ARB 0x2017 +#define WGL_GREEN_SHIFT_ARB 0x2018 +#define WGL_BLUE_BITS_ARB 0x2019 +#define WGL_BLUE_SHIFT_ARB 0x201A +#define WGL_ALPHA_BITS_ARB 0x201B +#define WGL_ALPHA_SHIFT_ARB 0x201C +#define WGL_ACCUM_BITS_ARB 0x201D +#define WGL_ACCUM_RED_BITS_ARB 0x201E +#define WGL_ACCUM_GREEN_BITS_ARB 0x201F +#define WGL_ACCUM_BLUE_BITS_ARB 0x2020 +#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 +#define WGL_DEPTH_BITS_ARB 0x2022 +#define WGL_STENCIL_BITS_ARB 0x2023 +#define WGL_AUX_BUFFERS_ARB 0x2024 +#define WGL_NO_ACCELERATION_ARB 0x2025 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026 +#define WGL_FULL_ACCELERATION_ARB 0x2027 +#define WGL_SWAP_EXCHANGE_ARB 0x2028 +#define WGL_SWAP_COPY_ARB 0x2029 +#define WGL_SWAP_UNDEFINED_ARB 0x202A +#define WGL_TYPE_RGBA_ARB 0x202B +#define WGL_TYPE_COLORINDEX_ARB 0x202C +#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 +#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 +#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 +#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A +#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B + +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, int *piValues); + +#define wglChoosePixelFormatARB WGLEW_GET_FUN(__wglewChoosePixelFormatARB) +#define wglGetPixelFormatAttribfvARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvARB) +#define wglGetPixelFormatAttribivARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribivARB) + +#define WGLEW_ARB_pixel_format WGLEW_GET_VAR(__WGLEW_ARB_pixel_format) + +#endif /* WGL_ARB_pixel_format */ + +/* ----------------------- WGL_ARB_pixel_format_float ---------------------- */ + +#ifndef WGL_ARB_pixel_format_float +#define WGL_ARB_pixel_format_float 1 + +#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0 + +#define WGLEW_ARB_pixel_format_float WGLEW_GET_VAR(__WGLEW_ARB_pixel_format_float) + +#endif /* WGL_ARB_pixel_format_float */ + +/* ------------------------- WGL_ARB_render_texture ------------------------ */ + +#ifndef WGL_ARB_render_texture +#define WGL_ARB_render_texture 1 + +#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 +#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 +#define WGL_TEXTURE_FORMAT_ARB 0x2072 +#define WGL_TEXTURE_TARGET_ARB 0x2073 +#define WGL_MIPMAP_TEXTURE_ARB 0x2074 +#define WGL_TEXTURE_RGB_ARB 0x2075 +#define WGL_TEXTURE_RGBA_ARB 0x2076 +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 +#define WGL_TEXTURE_1D_ARB 0x2079 +#define WGL_TEXTURE_2D_ARB 0x207A +#define WGL_MIPMAP_LEVEL_ARB 0x207B +#define WGL_CUBE_MAP_FACE_ARB 0x207C +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 +#define WGL_FRONT_LEFT_ARB 0x2083 +#define WGL_FRONT_RIGHT_ARB 0x2084 +#define WGL_BACK_LEFT_ARB 0x2085 +#define WGL_BACK_RIGHT_ARB 0x2086 +#define WGL_AUX0_ARB 0x2087 +#define WGL_AUX1_ARB 0x2088 +#define WGL_AUX2_ARB 0x2089 +#define WGL_AUX3_ARB 0x208A +#define WGL_AUX4_ARB 0x208B +#define WGL_AUX5_ARB 0x208C +#define WGL_AUX6_ARB 0x208D +#define WGL_AUX7_ARB 0x208E +#define WGL_AUX8_ARB 0x208F +#define WGL_AUX9_ARB 0x2090 + +typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int* piAttribList); + +#define wglBindTexImageARB WGLEW_GET_FUN(__wglewBindTexImageARB) +#define wglReleaseTexImageARB WGLEW_GET_FUN(__wglewReleaseTexImageARB) +#define wglSetPbufferAttribARB WGLEW_GET_FUN(__wglewSetPbufferAttribARB) + +#define WGLEW_ARB_render_texture WGLEW_GET_VAR(__WGLEW_ARB_render_texture) + +#endif /* WGL_ARB_render_texture */ + +/* ----------------------- WGL_ATI_pixel_format_float ---------------------- */ + +#ifndef WGL_ATI_pixel_format_float +#define WGL_ATI_pixel_format_float 1 + +#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0 +#define GL_RGBA_FLOAT_MODE_ATI 0x8820 +#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835 + +#define WGLEW_ATI_pixel_format_float WGLEW_GET_VAR(__WGLEW_ATI_pixel_format_float) + +#endif /* WGL_ATI_pixel_format_float */ + +/* -------------------- WGL_ATI_render_texture_rectangle ------------------- */ + +#ifndef WGL_ATI_render_texture_rectangle +#define WGL_ATI_render_texture_rectangle 1 + +#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5 + +#define WGLEW_ATI_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_ATI_render_texture_rectangle) + +#endif /* WGL_ATI_render_texture_rectangle */ + +/* ------------------- WGL_EXT_create_context_es2_profile ------------------ */ + +#ifndef WGL_EXT_create_context_es2_profile +#define WGL_EXT_create_context_es2_profile 1 + +#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 + +#define WGLEW_EXT_create_context_es2_profile WGLEW_GET_VAR(__WGLEW_EXT_create_context_es2_profile) + +#endif /* WGL_EXT_create_context_es2_profile */ + +/* -------------------------- WGL_EXT_depth_float -------------------------- */ + +#ifndef WGL_EXT_depth_float +#define WGL_EXT_depth_float 1 + +#define WGL_DEPTH_FLOAT_EXT 0x2040 + +#define WGLEW_EXT_depth_float WGLEW_GET_VAR(__WGLEW_EXT_depth_float) + +#endif /* WGL_EXT_depth_float */ + +/* ---------------------- WGL_EXT_display_color_table ---------------------- */ + +#ifndef WGL_EXT_display_color_table +#define WGL_EXT_display_color_table 1 + +typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef void (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (GLushort* table, GLuint length); + +#define wglBindDisplayColorTableEXT WGLEW_GET_FUN(__wglewBindDisplayColorTableEXT) +#define wglCreateDisplayColorTableEXT WGLEW_GET_FUN(__wglewCreateDisplayColorTableEXT) +#define wglDestroyDisplayColorTableEXT WGLEW_GET_FUN(__wglewDestroyDisplayColorTableEXT) +#define wglLoadDisplayColorTableEXT WGLEW_GET_FUN(__wglewLoadDisplayColorTableEXT) + +#define WGLEW_EXT_display_color_table WGLEW_GET_VAR(__WGLEW_EXT_display_color_table) + +#endif /* WGL_EXT_display_color_table */ + +/* ----------------------- WGL_EXT_extensions_string ----------------------- */ + +#ifndef WGL_EXT_extensions_string +#define WGL_EXT_extensions_string 1 + +typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void); + +#define wglGetExtensionsStringEXT WGLEW_GET_FUN(__wglewGetExtensionsStringEXT) + +#define WGLEW_EXT_extensions_string WGLEW_GET_VAR(__WGLEW_EXT_extensions_string) + +#endif /* WGL_EXT_extensions_string */ + +/* ------------------------ WGL_EXT_framebuffer_sRGB ----------------------- */ + +#ifndef WGL_EXT_framebuffer_sRGB +#define WGL_EXT_framebuffer_sRGB 1 + +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9 + +#define WGLEW_EXT_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_EXT_framebuffer_sRGB) + +#endif /* WGL_EXT_framebuffer_sRGB */ + +/* ----------------------- WGL_EXT_make_current_read ----------------------- */ + +#ifndef WGL_EXT_make_current_read +#define WGL_EXT_make_current_read 1 + +#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043 + +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); + +#define wglGetCurrentReadDCEXT WGLEW_GET_FUN(__wglewGetCurrentReadDCEXT) +#define wglMakeContextCurrentEXT WGLEW_GET_FUN(__wglewMakeContextCurrentEXT) + +#define WGLEW_EXT_make_current_read WGLEW_GET_VAR(__WGLEW_EXT_make_current_read) + +#endif /* WGL_EXT_make_current_read */ + +/* -------------------------- WGL_EXT_multisample -------------------------- */ + +#ifndef WGL_EXT_multisample +#define WGL_EXT_multisample 1 + +#define WGL_SAMPLE_BUFFERS_EXT 0x2041 +#define WGL_SAMPLES_EXT 0x2042 + +#define WGLEW_EXT_multisample WGLEW_GET_VAR(__WGLEW_EXT_multisample) + +#endif /* WGL_EXT_multisample */ + +/* ---------------------------- WGL_EXT_pbuffer ---------------------------- */ + +#ifndef WGL_EXT_pbuffer +#define WGL_EXT_pbuffer 1 + +#define WGL_DRAW_TO_PBUFFER_EXT 0x202D +#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E +#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030 +#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031 +#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032 +#define WGL_PBUFFER_LARGEST_EXT 0x2033 +#define WGL_PBUFFER_WIDTH_EXT 0x2034 +#define WGL_PBUFFER_HEIGHT_EXT 0x2035 + +DECLARE_HANDLE(HPBUFFEREXT); + +typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int* piValue); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC); + +#define wglCreatePbufferEXT WGLEW_GET_FUN(__wglewCreatePbufferEXT) +#define wglDestroyPbufferEXT WGLEW_GET_FUN(__wglewDestroyPbufferEXT) +#define wglGetPbufferDCEXT WGLEW_GET_FUN(__wglewGetPbufferDCEXT) +#define wglQueryPbufferEXT WGLEW_GET_FUN(__wglewQueryPbufferEXT) +#define wglReleasePbufferDCEXT WGLEW_GET_FUN(__wglewReleasePbufferDCEXT) + +#define WGLEW_EXT_pbuffer WGLEW_GET_VAR(__WGLEW_EXT_pbuffer) + +#endif /* WGL_EXT_pbuffer */ + +/* -------------------------- WGL_EXT_pixel_format ------------------------- */ + +#ifndef WGL_EXT_pixel_format +#define WGL_EXT_pixel_format 1 + +#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000 +#define WGL_DRAW_TO_WINDOW_EXT 0x2001 +#define WGL_DRAW_TO_BITMAP_EXT 0x2002 +#define WGL_ACCELERATION_EXT 0x2003 +#define WGL_NEED_PALETTE_EXT 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006 +#define WGL_SWAP_METHOD_EXT 0x2007 +#define WGL_NUMBER_OVERLAYS_EXT 0x2008 +#define WGL_NUMBER_UNDERLAYS_EXT 0x2009 +#define WGL_TRANSPARENT_EXT 0x200A +#define WGL_TRANSPARENT_VALUE_EXT 0x200B +#define WGL_SHARE_DEPTH_EXT 0x200C +#define WGL_SHARE_STENCIL_EXT 0x200D +#define WGL_SHARE_ACCUM_EXT 0x200E +#define WGL_SUPPORT_GDI_EXT 0x200F +#define WGL_SUPPORT_OPENGL_EXT 0x2010 +#define WGL_DOUBLE_BUFFER_EXT 0x2011 +#define WGL_STEREO_EXT 0x2012 +#define WGL_PIXEL_TYPE_EXT 0x2013 +#define WGL_COLOR_BITS_EXT 0x2014 +#define WGL_RED_BITS_EXT 0x2015 +#define WGL_RED_SHIFT_EXT 0x2016 +#define WGL_GREEN_BITS_EXT 0x2017 +#define WGL_GREEN_SHIFT_EXT 0x2018 +#define WGL_BLUE_BITS_EXT 0x2019 +#define WGL_BLUE_SHIFT_EXT 0x201A +#define WGL_ALPHA_BITS_EXT 0x201B +#define WGL_ALPHA_SHIFT_EXT 0x201C +#define WGL_ACCUM_BITS_EXT 0x201D +#define WGL_ACCUM_RED_BITS_EXT 0x201E +#define WGL_ACCUM_GREEN_BITS_EXT 0x201F +#define WGL_ACCUM_BLUE_BITS_EXT 0x2020 +#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021 +#define WGL_DEPTH_BITS_EXT 0x2022 +#define WGL_STENCIL_BITS_EXT 0x2023 +#define WGL_AUX_BUFFERS_EXT 0x2024 +#define WGL_NO_ACCELERATION_EXT 0x2025 +#define WGL_GENERIC_ACCELERATION_EXT 0x2026 +#define WGL_FULL_ACCELERATION_EXT 0x2027 +#define WGL_SWAP_EXCHANGE_EXT 0x2028 +#define WGL_SWAP_COPY_EXT 0x2029 +#define WGL_SWAP_UNDEFINED_EXT 0x202A +#define WGL_TYPE_RGBA_EXT 0x202B +#define WGL_TYPE_COLORINDEX_EXT 0x202C + +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, int *piValues); + +#define wglChoosePixelFormatEXT WGLEW_GET_FUN(__wglewChoosePixelFormatEXT) +#define wglGetPixelFormatAttribfvEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvEXT) +#define wglGetPixelFormatAttribivEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribivEXT) + +#define WGLEW_EXT_pixel_format WGLEW_GET_VAR(__WGLEW_EXT_pixel_format) + +#endif /* WGL_EXT_pixel_format */ + +/* ------------------- WGL_EXT_pixel_format_packed_float ------------------- */ + +#ifndef WGL_EXT_pixel_format_packed_float +#define WGL_EXT_pixel_format_packed_float 1 + +#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8 + +#define WGLEW_EXT_pixel_format_packed_float WGLEW_GET_VAR(__WGLEW_EXT_pixel_format_packed_float) + +#endif /* WGL_EXT_pixel_format_packed_float */ + +/* -------------------------- WGL_EXT_swap_control ------------------------- */ + +#ifndef WGL_EXT_swap_control +#define WGL_EXT_swap_control 1 + +typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void); +typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); + +#define wglGetSwapIntervalEXT WGLEW_GET_FUN(__wglewGetSwapIntervalEXT) +#define wglSwapIntervalEXT WGLEW_GET_FUN(__wglewSwapIntervalEXT) + +#define WGLEW_EXT_swap_control WGLEW_GET_VAR(__WGLEW_EXT_swap_control) + +#endif /* WGL_EXT_swap_control */ + +/* --------------------- WGL_I3D_digital_video_control --------------------- */ + +#ifndef WGL_I3D_digital_video_control +#define WGL_I3D_digital_video_control 1 + +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050 +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051 +#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052 +#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053 + +typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); +typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); + +#define wglGetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewGetDigitalVideoParametersI3D) +#define wglSetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewSetDigitalVideoParametersI3D) + +#define WGLEW_I3D_digital_video_control WGLEW_GET_VAR(__WGLEW_I3D_digital_video_control) + +#endif /* WGL_I3D_digital_video_control */ + +/* ----------------------------- WGL_I3D_gamma ----------------------------- */ + +#ifndef WGL_I3D_gamma +#define WGL_I3D_gamma 1 + +#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E +#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F + +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT* puRed, USHORT *puGreen, USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT* puRed, const USHORT *puGreen, const USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); + +#define wglGetGammaTableI3D WGLEW_GET_FUN(__wglewGetGammaTableI3D) +#define wglGetGammaTableParametersI3D WGLEW_GET_FUN(__wglewGetGammaTableParametersI3D) +#define wglSetGammaTableI3D WGLEW_GET_FUN(__wglewSetGammaTableI3D) +#define wglSetGammaTableParametersI3D WGLEW_GET_FUN(__wglewSetGammaTableParametersI3D) + +#define WGLEW_I3D_gamma WGLEW_GET_VAR(__WGLEW_I3D_gamma) + +#endif /* WGL_I3D_gamma */ + +/* ---------------------------- WGL_I3D_genlock ---------------------------- */ + +#ifndef WGL_I3D_genlock +#define WGL_I3D_genlock 1 + +#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044 +#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045 +#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046 +#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047 +#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048 +#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049 +#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A +#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B +#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C + +typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT* uRate); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT* uDelay); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT* uEdge); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT* uSource); +typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL* pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT* uMaxLineDelay, UINT *uMaxPixelDelay); + +#define wglDisableGenlockI3D WGLEW_GET_FUN(__wglewDisableGenlockI3D) +#define wglEnableGenlockI3D WGLEW_GET_FUN(__wglewEnableGenlockI3D) +#define wglGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGenlockSampleRateI3D) +#define wglGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGenlockSourceDelayI3D) +#define wglGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGenlockSourceEdgeI3D) +#define wglGenlockSourceI3D WGLEW_GET_FUN(__wglewGenlockSourceI3D) +#define wglGetGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGetGenlockSampleRateI3D) +#define wglGetGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGetGenlockSourceDelayI3D) +#define wglGetGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGetGenlockSourceEdgeI3D) +#define wglGetGenlockSourceI3D WGLEW_GET_FUN(__wglewGetGenlockSourceI3D) +#define wglIsEnabledGenlockI3D WGLEW_GET_FUN(__wglewIsEnabledGenlockI3D) +#define wglQueryGenlockMaxSourceDelayI3D WGLEW_GET_FUN(__wglewQueryGenlockMaxSourceDelayI3D) + +#define WGLEW_I3D_genlock WGLEW_GET_VAR(__WGLEW_I3D_genlock) + +#endif /* WGL_I3D_genlock */ + +/* -------------------------- WGL_I3D_image_buffer ------------------------- */ + +#ifndef WGL_I3D_image_buffer +#define WGL_I3D_image_buffer 1 + +#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001 +#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002 + +typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, HANDLE* pEvent, LPVOID *pAddress, DWORD *pSize, UINT count); +typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags); +typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress); +typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, LPVOID* pAddress, UINT count); + +#define wglAssociateImageBufferEventsI3D WGLEW_GET_FUN(__wglewAssociateImageBufferEventsI3D) +#define wglCreateImageBufferI3D WGLEW_GET_FUN(__wglewCreateImageBufferI3D) +#define wglDestroyImageBufferI3D WGLEW_GET_FUN(__wglewDestroyImageBufferI3D) +#define wglReleaseImageBufferEventsI3D WGLEW_GET_FUN(__wglewReleaseImageBufferEventsI3D) + +#define WGLEW_I3D_image_buffer WGLEW_GET_VAR(__WGLEW_I3D_image_buffer) + +#endif /* WGL_I3D_image_buffer */ + +/* ------------------------ WGL_I3D_swap_frame_lock ------------------------ */ + +#ifndef WGL_I3D_swap_frame_lock +#define WGL_I3D_swap_frame_lock 1 + +typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL* pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL* pFlag); + +#define wglDisableFrameLockI3D WGLEW_GET_FUN(__wglewDisableFrameLockI3D) +#define wglEnableFrameLockI3D WGLEW_GET_FUN(__wglewEnableFrameLockI3D) +#define wglIsEnabledFrameLockI3D WGLEW_GET_FUN(__wglewIsEnabledFrameLockI3D) +#define wglQueryFrameLockMasterI3D WGLEW_GET_FUN(__wglewQueryFrameLockMasterI3D) + +#define WGLEW_I3D_swap_frame_lock WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_lock) + +#endif /* WGL_I3D_swap_frame_lock */ + +/* ------------------------ WGL_I3D_swap_frame_usage ----------------------- */ + +#ifndef WGL_I3D_swap_frame_usage +#define WGL_I3D_swap_frame_usage 1 + +typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float* pUsage); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD* pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); + +#define wglBeginFrameTrackingI3D WGLEW_GET_FUN(__wglewBeginFrameTrackingI3D) +#define wglEndFrameTrackingI3D WGLEW_GET_FUN(__wglewEndFrameTrackingI3D) +#define wglGetFrameUsageI3D WGLEW_GET_FUN(__wglewGetFrameUsageI3D) +#define wglQueryFrameTrackingI3D WGLEW_GET_FUN(__wglewQueryFrameTrackingI3D) + +#define WGLEW_I3D_swap_frame_usage WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_usage) + +#endif /* WGL_I3D_swap_frame_usage */ + +/* --------------------------- WGL_NV_DX_interop --------------------------- */ + +#ifndef WGL_NV_DX_interop +#define WGL_NV_DX_interop 1 + +#define WGL_ACCESS_READ_ONLY_NV 0x0000 +#define WGL_ACCESS_READ_WRITE_NV 0x0001 +#define WGL_ACCESS_WRITE_DISCARD_NV 0x0002 + +typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice); +typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects); +typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access); +typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void* dxDevice); +typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void* dxObject, GLuint name, GLenum type, GLenum access); +typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void* dxObject, HANDLE shareHandle); +typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects); +typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject); + +#define wglDXCloseDeviceNV WGLEW_GET_FUN(__wglewDXCloseDeviceNV) +#define wglDXLockObjectsNV WGLEW_GET_FUN(__wglewDXLockObjectsNV) +#define wglDXObjectAccessNV WGLEW_GET_FUN(__wglewDXObjectAccessNV) +#define wglDXOpenDeviceNV WGLEW_GET_FUN(__wglewDXOpenDeviceNV) +#define wglDXRegisterObjectNV WGLEW_GET_FUN(__wglewDXRegisterObjectNV) +#define wglDXSetResourceShareHandleNV WGLEW_GET_FUN(__wglewDXSetResourceShareHandleNV) +#define wglDXUnlockObjectsNV WGLEW_GET_FUN(__wglewDXUnlockObjectsNV) +#define wglDXUnregisterObjectNV WGLEW_GET_FUN(__wglewDXUnregisterObjectNV) + +#define WGLEW_NV_DX_interop WGLEW_GET_VAR(__WGLEW_NV_DX_interop) + +#endif /* WGL_NV_DX_interop */ + +/* --------------------------- WGL_NV_copy_image --------------------------- */ + +#ifndef WGL_NV_copy_image +#define WGL_NV_copy_image 1 + +typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); + +#define wglCopyImageSubDataNV WGLEW_GET_FUN(__wglewCopyImageSubDataNV) + +#define WGLEW_NV_copy_image WGLEW_GET_VAR(__WGLEW_NV_copy_image) + +#endif /* WGL_NV_copy_image */ + +/* -------------------------- WGL_NV_float_buffer -------------------------- */ + +#ifndef WGL_NV_float_buffer +#define WGL_NV_float_buffer 1 + +#define WGL_FLOAT_COMPONENTS_NV 0x20B0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4 +#define WGL_TEXTURE_FLOAT_R_NV 0x20B5 +#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6 +#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7 +#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8 + +#define WGLEW_NV_float_buffer WGLEW_GET_VAR(__WGLEW_NV_float_buffer) + +#endif /* WGL_NV_float_buffer */ + +/* -------------------------- WGL_NV_gpu_affinity -------------------------- */ + +#ifndef WGL_NV_gpu_affinity +#define WGL_NV_gpu_affinity 1 + +#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0 +#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1 + +DECLARE_HANDLE(HGPUNV); +typedef struct _GPU_DEVICE { + DWORD cb; + CHAR DeviceName[32]; + CHAR DeviceString[128]; + DWORD Flags; + RECT rcVirtualScreen; +} GPU_DEVICE, *PGPU_DEVICE; + +typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList); +typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc); +typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu); + +#define wglCreateAffinityDCNV WGLEW_GET_FUN(__wglewCreateAffinityDCNV) +#define wglDeleteDCNV WGLEW_GET_FUN(__wglewDeleteDCNV) +#define wglEnumGpuDevicesNV WGLEW_GET_FUN(__wglewEnumGpuDevicesNV) +#define wglEnumGpusFromAffinityDCNV WGLEW_GET_FUN(__wglewEnumGpusFromAffinityDCNV) +#define wglEnumGpusNV WGLEW_GET_FUN(__wglewEnumGpusNV) + +#define WGLEW_NV_gpu_affinity WGLEW_GET_VAR(__WGLEW_NV_gpu_affinity) + +#endif /* WGL_NV_gpu_affinity */ + +/* ---------------------- WGL_NV_multisample_coverage ---------------------- */ + +#ifndef WGL_NV_multisample_coverage +#define WGL_NV_multisample_coverage 1 + +#define WGL_COVERAGE_SAMPLES_NV 0x2042 +#define WGL_COLOR_SAMPLES_NV 0x20B9 + +#define WGLEW_NV_multisample_coverage WGLEW_GET_VAR(__WGLEW_NV_multisample_coverage) + +#endif /* WGL_NV_multisample_coverage */ + +/* -------------------------- WGL_NV_present_video ------------------------- */ + +#ifndef WGL_NV_present_video +#define WGL_NV_present_video 1 + +#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0 + +DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); + +typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDc, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int* piAttribList); +typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDc, HVIDEOOUTPUTDEVICENV* phDeviceList); +typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int* piValue); + +#define wglBindVideoDeviceNV WGLEW_GET_FUN(__wglewBindVideoDeviceNV) +#define wglEnumerateVideoDevicesNV WGLEW_GET_FUN(__wglewEnumerateVideoDevicesNV) +#define wglQueryCurrentContextNV WGLEW_GET_FUN(__wglewQueryCurrentContextNV) + +#define WGLEW_NV_present_video WGLEW_GET_VAR(__WGLEW_NV_present_video) + +#endif /* WGL_NV_present_video */ + +/* ---------------------- WGL_NV_render_depth_texture ---------------------- */ + +#ifndef WGL_NV_render_depth_texture +#define WGL_NV_render_depth_texture 1 + +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4 +#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5 +#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6 +#define WGL_DEPTH_COMPONENT_NV 0x20A7 + +#define WGLEW_NV_render_depth_texture WGLEW_GET_VAR(__WGLEW_NV_render_depth_texture) + +#endif /* WGL_NV_render_depth_texture */ + +/* -------------------- WGL_NV_render_texture_rectangle -------------------- */ + +#ifndef WGL_NV_render_texture_rectangle +#define WGL_NV_render_texture_rectangle 1 + +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1 +#define WGL_TEXTURE_RECTANGLE_NV 0x20A2 + +#define WGLEW_NV_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_NV_render_texture_rectangle) + +#endif /* WGL_NV_render_texture_rectangle */ + +/* --------------------------- WGL_NV_swap_group --------------------------- */ + +#ifndef WGL_NV_swap_group +#define WGL_NV_swap_group 1 + +typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); +typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint* count); +typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint* maxGroups, GLuint *maxBarriers); +typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint* group, GLuint *barrier); +typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); + +#define wglBindSwapBarrierNV WGLEW_GET_FUN(__wglewBindSwapBarrierNV) +#define wglJoinSwapGroupNV WGLEW_GET_FUN(__wglewJoinSwapGroupNV) +#define wglQueryFrameCountNV WGLEW_GET_FUN(__wglewQueryFrameCountNV) +#define wglQueryMaxSwapGroupsNV WGLEW_GET_FUN(__wglewQueryMaxSwapGroupsNV) +#define wglQuerySwapGroupNV WGLEW_GET_FUN(__wglewQuerySwapGroupNV) +#define wglResetFrameCountNV WGLEW_GET_FUN(__wglewResetFrameCountNV) + +#define WGLEW_NV_swap_group WGLEW_GET_VAR(__WGLEW_NV_swap_group) + +#endif /* WGL_NV_swap_group */ + +/* ----------------------- WGL_NV_vertex_array_range ----------------------- */ + +#ifndef WGL_NV_vertex_array_range +#define WGL_NV_vertex_array_range 1 + +typedef void * (WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority); +typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer); + +#define wglAllocateMemoryNV WGLEW_GET_FUN(__wglewAllocateMemoryNV) +#define wglFreeMemoryNV WGLEW_GET_FUN(__wglewFreeMemoryNV) + +#define WGLEW_NV_vertex_array_range WGLEW_GET_VAR(__WGLEW_NV_vertex_array_range) + +#endif /* WGL_NV_vertex_array_range */ + +/* -------------------------- WGL_NV_video_capture ------------------------- */ + +#ifndef WGL_NV_video_capture +#define WGL_NV_video_capture 1 + +#define WGL_UNIQUE_ID_NV 0x20CE +#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF + +DECLARE_HANDLE(HVIDEOINPUTDEVICENV); + +typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); +typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV* phDeviceList); +typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int* piValue); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); + +#define wglBindVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewBindVideoCaptureDeviceNV) +#define wglEnumerateVideoCaptureDevicesNV WGLEW_GET_FUN(__wglewEnumerateVideoCaptureDevicesNV) +#define wglLockVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewLockVideoCaptureDeviceNV) +#define wglQueryVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewQueryVideoCaptureDeviceNV) +#define wglReleaseVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewReleaseVideoCaptureDeviceNV) + +#define WGLEW_NV_video_capture WGLEW_GET_VAR(__WGLEW_NV_video_capture) + +#endif /* WGL_NV_video_capture */ + +/* -------------------------- WGL_NV_video_output -------------------------- */ + +#ifndef WGL_NV_video_output +#define WGL_NV_video_output 1 + +#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0 +#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1 +#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2 +#define WGL_VIDEO_OUT_COLOR_NV 0x20C3 +#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4 +#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5 +#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 +#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 +#define WGL_VIDEO_OUT_FRAME 0x20C8 +#define WGL_VIDEO_OUT_FIELD_1 0x20C9 +#define WGL_VIDEO_OUT_FIELD_2 0x20CA +#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB +#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC + +DECLARE_HANDLE(HPVIDEODEV); + +typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV* hVideoDevice); +typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long* pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long* pulCounterPbuffer, BOOL bBlock); + +#define wglBindVideoImageNV WGLEW_GET_FUN(__wglewBindVideoImageNV) +#define wglGetVideoDeviceNV WGLEW_GET_FUN(__wglewGetVideoDeviceNV) +#define wglGetVideoInfoNV WGLEW_GET_FUN(__wglewGetVideoInfoNV) +#define wglReleaseVideoDeviceNV WGLEW_GET_FUN(__wglewReleaseVideoDeviceNV) +#define wglReleaseVideoImageNV WGLEW_GET_FUN(__wglewReleaseVideoImageNV) +#define wglSendPbufferToVideoNV WGLEW_GET_FUN(__wglewSendPbufferToVideoNV) + +#define WGLEW_NV_video_output WGLEW_GET_VAR(__WGLEW_NV_video_output) + +#endif /* WGL_NV_video_output */ + +/* -------------------------- WGL_OML_sync_control ------------------------- */ + +#ifndef WGL_OML_sync_control +#define WGL_OML_sync_control 1 + +typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32* numerator, INT32 *denominator); +typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64* ust, INT64 *msc, INT64 *sbc); +typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64* ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64* ust, INT64 *msc, INT64 *sbc); + +#define wglGetMscRateOML WGLEW_GET_FUN(__wglewGetMscRateOML) +#define wglGetSyncValuesOML WGLEW_GET_FUN(__wglewGetSyncValuesOML) +#define wglSwapBuffersMscOML WGLEW_GET_FUN(__wglewSwapBuffersMscOML) +#define wglSwapLayerBuffersMscOML WGLEW_GET_FUN(__wglewSwapLayerBuffersMscOML) +#define wglWaitForMscOML WGLEW_GET_FUN(__wglewWaitForMscOML) +#define wglWaitForSbcOML WGLEW_GET_FUN(__wglewWaitForSbcOML) + +#define WGLEW_OML_sync_control WGLEW_GET_VAR(__WGLEW_OML_sync_control) + +#endif /* WGL_OML_sync_control */ + +/* ------------------------------------------------------------------------- */ + +#ifdef GLEW_MX +#define WGLEW_EXPORT +#else +#define WGLEW_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#ifdef GLEW_MX +struct WGLEWContextStruct +{ +#endif /* GLEW_MX */ + +WGLEW_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL; + +WGLEW_EXPORT PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD; +WGLEW_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD; +WGLEW_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD; +WGLEW_EXPORT PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD; +WGLEW_EXPORT PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD; +WGLEW_EXPORT PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD; +WGLEW_EXPORT PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD; +WGLEW_EXPORT PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD; +WGLEW_EXPORT PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD; + +WGLEW_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB; +WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB; +WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB; +WGLEW_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB; + +WGLEW_EXPORT PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB; + +WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB; + +WGLEW_EXPORT PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB; +WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB; + +WGLEW_EXPORT PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB; +WGLEW_EXPORT PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB; +WGLEW_EXPORT PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB; +WGLEW_EXPORT PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB; +WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB; + +WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB; + +WGLEW_EXPORT PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB; +WGLEW_EXPORT PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB; +WGLEW_EXPORT PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB; + +WGLEW_EXPORT PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT; + +WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT; + +WGLEW_EXPORT PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT; +WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT; + +WGLEW_EXPORT PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT; +WGLEW_EXPORT PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT; +WGLEW_EXPORT PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT; +WGLEW_EXPORT PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT; +WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT; + +WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT; + +WGLEW_EXPORT PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT; +WGLEW_EXPORT PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT; + +WGLEW_EXPORT PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D; +WGLEW_EXPORT PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D; + +WGLEW_EXPORT PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D; +WGLEW_EXPORT PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D; +WGLEW_EXPORT PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D; +WGLEW_EXPORT PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D; + +WGLEW_EXPORT PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D; +WGLEW_EXPORT PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D; +WGLEW_EXPORT PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D; +WGLEW_EXPORT PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D; +WGLEW_EXPORT PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D; + +WGLEW_EXPORT PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D; +WGLEW_EXPORT PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D; +WGLEW_EXPORT PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D; +WGLEW_EXPORT PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D; + +WGLEW_EXPORT PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D; +WGLEW_EXPORT PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D; +WGLEW_EXPORT PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D; +WGLEW_EXPORT PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D; + +WGLEW_EXPORT PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D; +WGLEW_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D; +WGLEW_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D; +WGLEW_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D; + +WGLEW_EXPORT PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV; +WGLEW_EXPORT PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV; +WGLEW_EXPORT PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV; +WGLEW_EXPORT PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV; +WGLEW_EXPORT PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV; +WGLEW_EXPORT PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV; +WGLEW_EXPORT PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV; +WGLEW_EXPORT PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV; + +WGLEW_EXPORT PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV; + +WGLEW_EXPORT PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV; +WGLEW_EXPORT PFNWGLDELETEDCNVPROC __wglewDeleteDCNV; +WGLEW_EXPORT PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV; +WGLEW_EXPORT PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV; +WGLEW_EXPORT PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV; + +WGLEW_EXPORT PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV; +WGLEW_EXPORT PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV; +WGLEW_EXPORT PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV; + +WGLEW_EXPORT PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV; +WGLEW_EXPORT PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV; +WGLEW_EXPORT PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV; +WGLEW_EXPORT PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV; +WGLEW_EXPORT PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV; +WGLEW_EXPORT PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV; + +WGLEW_EXPORT PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV; +WGLEW_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV; + +WGLEW_EXPORT PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV; +WGLEW_EXPORT PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV; +WGLEW_EXPORT PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV; +WGLEW_EXPORT PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV; +WGLEW_EXPORT PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV; + +WGLEW_EXPORT PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV; +WGLEW_EXPORT PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV; +WGLEW_EXPORT PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV; +WGLEW_EXPORT PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV; +WGLEW_EXPORT PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV; +WGLEW_EXPORT PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV; + +WGLEW_EXPORT PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML; +WGLEW_EXPORT PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML; +WGLEW_EXPORT PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML; +WGLEW_EXPORT PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML; +WGLEW_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML; +WGLEW_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML; +WGLEW_EXPORT GLboolean __WGLEW_3DFX_multisample; +WGLEW_EXPORT GLboolean __WGLEW_3DL_stereo_control; +WGLEW_EXPORT GLboolean __WGLEW_AMD_gpu_association; +WGLEW_EXPORT GLboolean __WGLEW_ARB_buffer_region; +WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context; +WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context_profile; +WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context_robustness; +WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string; +WGLEW_EXPORT GLboolean __WGLEW_ARB_framebuffer_sRGB; +WGLEW_EXPORT GLboolean __WGLEW_ARB_make_current_read; +WGLEW_EXPORT GLboolean __WGLEW_ARB_multisample; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pbuffer; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format_float; +WGLEW_EXPORT GLboolean __WGLEW_ARB_render_texture; +WGLEW_EXPORT GLboolean __WGLEW_ATI_pixel_format_float; +WGLEW_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle; +WGLEW_EXPORT GLboolean __WGLEW_EXT_create_context_es2_profile; +WGLEW_EXPORT GLboolean __WGLEW_EXT_depth_float; +WGLEW_EXPORT GLboolean __WGLEW_EXT_display_color_table; +WGLEW_EXPORT GLboolean __WGLEW_EXT_extensions_string; +WGLEW_EXPORT GLboolean __WGLEW_EXT_framebuffer_sRGB; +WGLEW_EXPORT GLboolean __WGLEW_EXT_make_current_read; +WGLEW_EXPORT GLboolean __WGLEW_EXT_multisample; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pbuffer; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format_packed_float; +WGLEW_EXPORT GLboolean __WGLEW_EXT_swap_control; +WGLEW_EXPORT GLboolean __WGLEW_I3D_digital_video_control; +WGLEW_EXPORT GLboolean __WGLEW_I3D_gamma; +WGLEW_EXPORT GLboolean __WGLEW_I3D_genlock; +WGLEW_EXPORT GLboolean __WGLEW_I3D_image_buffer; +WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock; +WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage; +WGLEW_EXPORT GLboolean __WGLEW_NV_DX_interop; +WGLEW_EXPORT GLboolean __WGLEW_NV_copy_image; +WGLEW_EXPORT GLboolean __WGLEW_NV_float_buffer; +WGLEW_EXPORT GLboolean __WGLEW_NV_gpu_affinity; +WGLEW_EXPORT GLboolean __WGLEW_NV_multisample_coverage; +WGLEW_EXPORT GLboolean __WGLEW_NV_present_video; +WGLEW_EXPORT GLboolean __WGLEW_NV_render_depth_texture; +WGLEW_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle; +WGLEW_EXPORT GLboolean __WGLEW_NV_swap_group; +WGLEW_EXPORT GLboolean __WGLEW_NV_vertex_array_range; +WGLEW_EXPORT GLboolean __WGLEW_NV_video_capture; +WGLEW_EXPORT GLboolean __WGLEW_NV_video_output; +WGLEW_EXPORT GLboolean __WGLEW_OML_sync_control; + +#ifdef GLEW_MX +}; /* WGLEWContextStruct */ +#endif /* GLEW_MX */ + +/* ------------------------------------------------------------------------- */ + +#ifdef GLEW_MX + +typedef struct WGLEWContextStruct WGLEWContext; +GLEWAPI GLenum wglewContextInit (WGLEWContext* ctx); +GLEWAPI GLboolean wglewContextIsSupported (const WGLEWContext* ctx, const char* name); + +#define wglewInit() wglewContextInit(wglewGetContext()) +#define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x) + +#define WGLEW_GET_VAR(x) (*(const GLboolean*)&(wglewGetContext()->x)) +#define WGLEW_GET_FUN(x) wglewGetContext()->x + +#else /* GLEW_MX */ + +#define WGLEW_GET_VAR(x) (*(const GLboolean*)&x) +#define WGLEW_GET_FUN(x) x + +GLEWAPI GLboolean wglewIsSupported (const char* name); + +#endif /* GLEW_MX */ + +GLEWAPI GLboolean wglewGetExtension (const char* name); + +#ifdef __cplusplus +} +#endif + +#undef GLEWAPI + +#endif /* __wglew_h__ */ diff --git a/lib/gwen/controls/gwen_base.cpp b/lib/gwen/controls/gwen_base.cpp new file mode 100644 index 0000000..52d5401 --- /dev/null +++ b/lib/gwen/controls/gwen_base.cpp @@ -0,0 +1,1193 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen.h" +#include "../gwen_baserender.h" +#include "../gwen_skin.h" +#include "../gwen_platform.h" +#include "../gwen_draganddrop.h" +#include "../gwen_tooltip.h" +#include "../gwen_utility.h" +#include + +#ifndef GWEN_NO_ANIMATION +#include "../gwen_anim.h" +#endif + +using namespace Gwen; +using namespace Controls; + +Base::Base( Base* pParent, const Gwen::String& Name ) +{ + m_Parent = NULL; + m_ActualParent = NULL; + m_InnerPanel = NULL; + m_Skin = NULL; + + SetName( Name ); + SetParent( pParent ); + + m_bHidden = false; + m_Bounds = Gwen::Rect(0,0,10,10); + m_Padding = Padding( 0, 0, 0, 0 ); + m_Margin = Margin( 0, 0, 0, 0 ); + + m_iDock = 0; + m_DragAndDrop_Package = NULL; + + RestrictToParent( false ); + + SetMouseInputEnabled( true ); + SetKeyboardInputEnabled( false ); + + Invalidate(); + SetCursor( Gwen::CursorType::Normal ); + SetToolTip( NULL ); + SetTabable( false ); + SetShouldDrawBackground( true ); + m_bDisabled = false; + m_bCacheTextureDirty = true; + m_bCacheToTexture = false; + + m_bIncludeInSize = true; + +} + +Base::~Base() +{ + { + Canvas* canvas = GetCanvas(); + if ( canvas ) + canvas->PreDeleteControl( this ); + } + + Base::List::iterator iter = Children.begin(); + while ( iter != Children.end() ) + { + Base* pChild = *iter; + iter = Children.erase( iter ); + delete pChild; + } + + for ( AccelMap::iterator accelIt = m_Accelerators.begin(); accelIt != m_Accelerators.end(); ++accelIt ) + { + delete accelIt->second; + } + m_Accelerators.clear(); + + SetParent( NULL ); + + if ( Gwen::HoveredControl == this ) Gwen::HoveredControl = NULL; + if ( Gwen::KeyboardFocus == this ) Gwen::KeyboardFocus = NULL; + if ( Gwen::MouseFocus == this ) Gwen::MouseFocus = NULL; + + DragAndDrop::ControlDeleted( this ); + ToolTip::ControlDeleted( this ); + + #ifndef GWEN_NO_ANIMATION + Anim::Cancel( this ); + #endif + + if ( m_DragAndDrop_Package ) + { + delete m_DragAndDrop_Package; + m_DragAndDrop_Package = NULL; + } +} + +void Base::Invalidate() +{ + m_bNeedsLayout = true; + m_bCacheTextureDirty = true; +} + +void Base::DelayedDelete() +{ + Canvas* canvas = GetCanvas(); + canvas->AddDelayedDelete( this ); +} + +Canvas* Base::GetCanvas() +{ + Base* pCanvas = m_Parent; + if ( !pCanvas ) return NULL; + + return pCanvas->GetCanvas(); +} + +void Base::SetParent(Base* pParent) +{ + if ( m_Parent == pParent ) return; + + if ( m_Parent ) + { + m_Parent->RemoveChild( this ); + } + + m_Parent = pParent; + m_ActualParent = NULL; + + if ( m_Parent ) + { + m_Parent->AddChild( this ); + } +} + +void Base::Dock( int iDock ) +{ + if ( m_iDock == iDock ) return; + + m_iDock = iDock; + + Invalidate(); + InvalidateParent(); +} + +int Base::GetDock() +{ + return m_iDock; +} + +bool Base::Hidden() const +{ + return m_bHidden; +} + +bool Base::Visible() const +{ + if ( Hidden() ) return false; + if ( GetParent() ) + { + return GetParent()->Visible(); + } + + return true; +} + +void Base::InvalidateChildren( bool bRecursive ) +{ + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + (*it)->Invalidate(); + + if ( bRecursive ) + (*it)->InvalidateChildren( bRecursive ); + } + + if ( m_InnerPanel ) + { + for ( Base::List::iterator it = m_InnerPanel->Children.begin(); it != m_InnerPanel->Children.end(); ++it ) + { + (*it)->Invalidate(); + + if ( bRecursive ) + (*it)->InvalidateChildren( bRecursive ); + } + } +} + +void Base::Position( int pos, int xpadding, int ypadding ) +{ + const Rect& bounds = GetParent()->GetInnerBounds(); + const Margin& margin = GetMargin(); + + int x = X(); + int y = Y(); + + if ( pos & Pos::Left ) x = bounds.x + xpadding + margin.left; + if ( pos & Pos::Right ) x = bounds.x + ( bounds.w - Width() - xpadding - margin.right ); + if ( pos & Pos::CenterH ) x = bounds.x + ( bounds.w - Width() ) * 0.5; + + if ( pos & Pos::Top ) y = bounds.y + ypadding; + if ( pos & Pos::Bottom ) y = bounds.y + ( bounds.h - Height() - ypadding ); + if ( pos & Pos::CenterV ) y = bounds.y + ( bounds.h - Height() ) * 0.5; + + SetPos( x, y ); +} + +void Base::SendToBack() +{ + if ( !m_ActualParent ) return; + if ( m_ActualParent->Children.front() == this ) return; + + m_ActualParent->Children.remove( this ); + m_ActualParent->Children.push_front( this ); + + InvalidateParent(); +} + +void Base::BringToFront() +{ + if ( !m_ActualParent ) return; + if ( m_ActualParent->Children.back() == this ) return; + + m_ActualParent->Children.remove( this ); + m_ActualParent->Children.push_back( this ); + + InvalidateParent(); + Redraw(); +} + +Controls::Base* Base::FindChildByName( const Gwen::String& name, bool bRecursive ) +{ + Base::List::iterator iter; + for (iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + if ( !pChild->GetName().empty() && pChild->GetName() == name ) + return pChild; + + if ( bRecursive ) + { + Controls::Base* pSubChild = pChild->FindChildByName( name, true ); + + if ( pSubChild ) + return pSubChild; + } + } + + return NULL; +} + +void Base::BringNextToControl( Controls::Base* pChild, bool bBehind ) +{ + if ( !m_ActualParent ) return; + + m_ActualParent->Children.remove( this ); + + Base::List::iterator it = stl::find( m_ActualParent->Children.begin(), m_ActualParent->Children.end(), pChild ); + if ( it == m_ActualParent->Children.end() ) + return BringToFront(); + + if ( bBehind ) + { + ++it; + + if ( it == m_ActualParent->Children.end() ) + return BringToFront(); + } + + m_ActualParent->Children.insert( it, this ); + InvalidateParent(); +} + +void Base::AddChild(Base* pChild) +{ + if ( m_InnerPanel ) + { + m_InnerPanel->AddChild( pChild ); + return; + } + + Children.push_back( pChild ); + OnChildAdded(pChild); + + pChild->m_ActualParent = this; + +} +void Base::RemoveChild(Base* pChild) +{ + // If we removed our innerpanel + // remove our pointer to it + if ( m_InnerPanel == pChild ) + { + m_InnerPanel = NULL; + } + + if ( m_InnerPanel ) + { + m_InnerPanel->RemoveChild( pChild ); + } + + Children.remove( pChild ); + OnChildRemoved(pChild); +} + +void Base::RemoveAllChildren() +{ + while ( Children.size() > 0 ) + { + RemoveChild( *Children.begin() ); + } +} + +unsigned int Base::NumChildren() +{ + // Include m_InnerPanel's children here? + + return Children.size(); +} + +Controls::Base* Base::GetChild( unsigned int i ) +{ + if ( i >= NumChildren() ) return NULL; + + for ( Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter ) + { + if ( i == 0 ) + return *iter; + + i--; + } + + // Should never happen. + return NULL; + +} + +void Base::OnChildAdded(Base* /*pChild*/) +{ + Invalidate(); +} + +void Base::OnChildRemoved(Base* /*pChild*/) +{ + Invalidate(); +} + +Skin::Base* Base::GetSkin( void ) +{ + if ( m_Skin ) return m_Skin; + if ( m_Parent ) return m_Parent->GetSkin(); + + Debug::AssertCheck( 0, "Base::GetSkin Returning NULL!\n" ); + return NULL; +} + +void Base::MoveBy( int x, int y ) +{ + MoveTo( X() + x, Y() + y ); +} + +void Base::MoveTo( int x, int y ) +{ + if ( m_bRestrictToParent && GetParent() ) + { + Base* pParent = GetParent(); + if ( x - GetPadding().left < pParent->GetMargin().left ) x = pParent->GetMargin().left + GetPadding().left; + if ( y - GetPadding().top < pParent->GetMargin().top ) y = pParent->GetMargin().top + GetPadding().top; + if ( x + Width() + GetPadding().right > pParent->Width() - pParent->GetMargin().right ) x = pParent->Width() - pParent->GetMargin().right - Width() - GetPadding().right; + if ( y + Height() + GetPadding().bottom > pParent->Height() - pParent->GetMargin().bottom ) y = pParent->Height() - pParent->GetMargin().bottom - Height() - GetPadding().bottom; + } + + SetBounds(x, y, Width(), Height()); +} + +void Base::SetPos( int x, int y ) +{ + SetBounds( x, y, Width(), Height() ); +} + +void Base::SetPosInParentBounds( int x, int y ) +{ + Base* pParent = GetParent(); + if (pParent == NULL) + return; + + x = pParent->GetPadding().left + x; + y = pParent->GetPadding().top + y; + + SetBounds(x, y, Width(), Height()); +} + +bool Base::SetSize( int w, int h ) +{ + return SetBounds( X(), Y(), w, h ); +} + +bool Base::SetSize( const Point& p ) +{ + return SetSize( p.x, p.y ); +} + +bool Base::SetBounds( const Gwen::Rect& bounds ) +{ + return SetBounds( bounds.x, bounds.y, bounds.w, bounds.h ); +} + +bool Base::SetBounds( int x, int y, int w, int h ) +{ + if ( m_Bounds.x == x && + m_Bounds.y == y && + m_Bounds.w == w && + m_Bounds.h == h ) + return false; + + Gwen::Rect oldBounds = GetBounds(); + + m_Bounds.x = x; + m_Bounds.y = y; + + m_Bounds.w = w; + m_Bounds.h = h; + + OnBoundsChanged( oldBounds ); + + return true; +} + +void Base::OnBoundsChanged(Gwen::Rect oldBounds) +{ + //Anything that needs to update on size changes + //Iterate my children and tell them I've changed + // + if ( GetParent() ) + GetParent()->OnChildBoundsChanged( oldBounds, this ); + + + if ( m_Bounds.w != oldBounds.w || m_Bounds.h != oldBounds.h ) + { + Invalidate(); + } + + Redraw(); + UpdateRenderBounds(); +} + +void Base::OnScaleChanged() +{ + for ( Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter ) + { + (*iter)->OnScaleChanged(); + } +} + +void Base::OnChildBoundsChanged( Gwen::Rect /*oldChildBounds*/, Base* /*pChild*/ ) +{ + +} + +void Base::Render( Gwen::Skin::Base* /*skin*/ ) +{ +} + +void Base::DoCacheRender( Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster ) +{ + Gwen::Renderer::Base* render = skin->GetRender(); + Gwen::Renderer::ICacheToTexture* cache = render->GetCTT(); + + if ( !cache ) return; + + Gwen::Point pOldRenderOffset = render->GetRenderOffset(); + + Gwen::Rect rOldRegion = render->ClipRegion(); + + if ( this != pMaster ) + { + render->AddRenderOffset( GetBounds() ); + render->AddClipRegion( GetBounds() ); + } + else + { + render->SetRenderOffset( Gwen::Point( 0, 0 ) ); + render->SetClipRegion( GetBounds() ); + } + + if ( m_bCacheTextureDirty && render->ClipRegionVisible() ) + { + render->StartClip(); + { + + if ( ShouldCacheToTexture() ) + cache->SetupCacheTexture( this ); + + //Render myself first + Render( skin ); + + if ( !Children.empty() ) + { + //Now render my kids + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + if ( pChild->Hidden() ) continue; + + pChild->DoCacheRender( skin, pMaster ); + } + } + + if ( ShouldCacheToTexture() ) + { + cache->FinishCacheTexture( this ); + m_bCacheTextureDirty = false; + } + } + render->EndClip(); + } + + render->SetClipRegion( rOldRegion ); + render->StartClip(); + { + render->SetRenderOffset( pOldRenderOffset ); + cache->DrawCachedControlTexture( this ); + } + render->EndClip(); +} + +void Base::DoRender( Gwen::Skin::Base* skin ) +{ + // If this control has a different skin, + // then so does its children. + if ( m_Skin ) + skin = m_Skin; + + // Do think + Think(); + + Gwen::Renderer::Base* render = skin->GetRender(); + + if ( render->GetCTT() && ShouldCacheToTexture() ) + { + DoCacheRender( skin, this ); + return; + } + + RenderRecursive( skin, GetBounds() ); +} + +void Base::RenderRecursive( Gwen::Skin::Base* skin, const Gwen::Rect& cliprect ) +{ + Gwen::Renderer::Base* render = skin->GetRender(); + + Gwen::Point pOldRenderOffset = render->GetRenderOffset(); + render->AddRenderOffset( cliprect ); + + RenderUnder( skin ); + + Gwen::Rect rOldRegion = render->ClipRegion(); + + // + // If this control is clipping, change the clip rect to ourselves + // ( if not then we still clip using our parents clip rect ) + // + if ( ShouldClip() ) + { + render->AddClipRegion( cliprect ); + + if ( !render->ClipRegionVisible() ) + { + render->SetRenderOffset( pOldRenderOffset ); + render->SetClipRegion( rOldRegion ); + return; + } + } + + // + // Render this control and children controls + // + render->StartClip(); + { + Render( skin ); + + if ( !Children.empty() ) + { + //Now render my kids + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + if ( pChild->Hidden() ) continue; + + pChild->DoRender( skin ); + } + } + } + render->EndClip(); + + // + // Render overlay/focus + // + { + render->SetClipRegion( rOldRegion ); + render->StartClip(); + { + RenderOver( skin ); + RenderFocus( skin ); + } + render->EndClip(); + render->SetRenderOffset( pOldRenderOffset ); + } + +} + +void Base::SetSkin( Skin::Base* skin, bool doChildren ) +{ + if ( m_Skin == skin ) return; + + m_Skin = skin; + Invalidate(); + Redraw(); + OnSkinChanged( skin ); + + if ( doChildren ) + { + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + (*it)->SetSkin( skin, true); + } + } +} + +void Base::OnSkinChanged( Skin::Base* /*skin*/ ) +{ + //Do something +} + +bool Base::OnMouseWheeled( int iDelta ) +{ + if ( m_ActualParent ) + return m_ActualParent->OnMouseWheeled( iDelta ); + + return false; +} + +void Base::OnMouseMoved( int /*x*/, int /*y*/, int /*deltaX*/, int /*deltaY*/ ) +{ +} + +void Base::OnMouseEnter() +{ + onHoverEnter.Call( this ); + + if ( GetToolTip() ) + ToolTip::Enable( this ); + else if ( GetParent() && GetParent()->GetToolTip() ) + ToolTip::Enable( GetParent() ); + + Redraw(); +} + +void Base::OnMouseLeave() +{ + onHoverLeave.Call( this ); + + if ( GetToolTip() ) + ToolTip::Disable( this ); + + Redraw(); +} + + +bool Base::IsHovered() +{ + return Gwen::HoveredControl == this; +} + +bool Base::ShouldDrawHover() +{ + return Gwen::MouseFocus == this || Gwen::MouseFocus == NULL; +} + +bool Base::HasFocus() +{ + return Gwen::KeyboardFocus == this; +} + +void Base::Focus() +{ + if ( Gwen::KeyboardFocus == this ) return; + + if ( Gwen::KeyboardFocus ) + Gwen::KeyboardFocus->OnLostKeyboardFocus(); + + Gwen::KeyboardFocus = this; + + OnKeyboardFocus(); + Redraw(); +} + +void Base::Blur() +{ + if ( Gwen::KeyboardFocus != this ) return; + + Gwen::KeyboardFocus = NULL; + OnLostKeyboardFocus(); + + Redraw(); +} + +bool Base::IsOnTop() +{ + if ( !GetParent() ) + return false; + + Base::List::iterator iter = GetParent()->Children.begin(); + Base* pChild = *iter; + + if ( pChild == this ) + return true; + + return false; +} + + +void Base::Touch() +{ + if ( GetParent() ) + GetParent()->OnChildTouched( this ); +} + +void Base::OnChildTouched( Controls::Base* /*pChild*/ ) +{ + Touch(); +} + +Base* Base::GetControlAt( int x, int y, bool bOnlyIfMouseEnabled ) +{ + if ( Hidden() ) + return NULL; + + if ( x < 0 || y < 0 || x >= Width() || y >= Height() ) + return NULL; + + Base::List::reverse_iterator iter; + for (iter = Children.rbegin(); iter != Children.rend(); ++iter) + { + Base* pChild = *iter; + Base* pFound = NULL; + pFound = pChild->GetControlAt( x - pChild->X(), y - pChild->Y(), bOnlyIfMouseEnabled ); + if ( pFound ) return pFound; + } + + if ( bOnlyIfMouseEnabled && !GetMouseInputEnabled() ) + return NULL; + + return this; +} + + +void Base::Layout( Skin::Base* skin ) +{ + if ( skin->GetRender()->GetCTT() && ShouldCacheToTexture() ) + skin->GetRender()->GetCTT()->CreateControlCacheTexture( this ); +} + +void Base::RecurseLayout( Skin::Base* skin ) +{ + if ( m_Skin ) skin = m_Skin; + if ( Hidden() ) return; + + if ( NeedsLayout() ) + { + m_bNeedsLayout = false; + Layout( skin ); + } + + Gwen::Rect rBounds = GetRenderBounds(); + + // Adjust bounds for padding + rBounds.x += m_Padding.left; + rBounds.w -= m_Padding.left + m_Padding.right; + rBounds.y += m_Padding.top; + rBounds.h -= m_Padding.top + m_Padding.bottom; + + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + + if ( pChild->Hidden() ) + continue; + + int iDock = pChild->GetDock(); + + if ( iDock & Pos::Fill ) + continue; + + + if ( iDock & Pos::Top ) + { + const Margin& margin = pChild->GetMargin(); + + pChild->SetBounds( rBounds.x + margin.left, rBounds.y + margin.top, rBounds.w - margin.left - margin.right, pChild->Height() ); + + int iHeight = margin.top + margin.bottom + pChild->Height(); + rBounds.y += iHeight; + rBounds.h -= iHeight; + } + + if ( iDock & Pos::Left ) + { + const Margin& margin = pChild->GetMargin(); + + pChild->SetBounds( rBounds.x + margin.left, rBounds.y + margin.top, pChild->Width(), rBounds.h - margin.top - margin.bottom ); + + int iWidth = margin.left + margin.right + pChild->Width(); + rBounds.x += iWidth; + rBounds.w -= iWidth; + } + + if ( iDock & Pos::Right ) + { + // TODO: THIS MARGIN CODE MIGHT NOT BE FULLY FUNCTIONAL + const Margin& margin = pChild->GetMargin(); + + pChild->SetBounds( (rBounds.x+rBounds.w)-pChild->Width()-margin.right, rBounds.y + margin.top, pChild->Width(), rBounds.h - margin.top - margin.bottom ); + + int iWidth = margin.left + margin.right + pChild->Width(); + rBounds.w -= iWidth; + } + + if ( iDock & Pos::Bottom ) + { + // TODO: THIS MARGIN CODE MIGHT NOT BE FULLY FUNCTIONAL + const Margin& margin = pChild->GetMargin(); + + pChild->SetBounds( rBounds.x + margin.left, (rBounds.y+rBounds.h)-pChild->Height()-margin.bottom, rBounds.w - margin.left - margin.right, pChild->Height() ); + rBounds.h -= pChild->Height() + margin.bottom + margin.top; + } + + pChild->RecurseLayout( skin ); + } + + m_InnerBounds = rBounds; + + // + // Fill uses the left over space, so do that now. + // + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + int iDock = pChild->GetDock(); + + if ( !(iDock & Pos::Fill) ) + continue; + + const Margin& margin = pChild->GetMargin(); + + pChild->SetBounds( rBounds.x + margin.left, rBounds.y + margin.top, rBounds.w - margin.left - margin.right, rBounds.h - margin.top - margin.bottom ); + pChild->RecurseLayout( skin ); + } + + + + PostLayout( skin ); + + + + if ( IsTabable() ) + { + if ( !GetCanvas()->FirstTab ) GetCanvas()->FirstTab = this; + if ( !GetCanvas()->NextTab ) GetCanvas()->NextTab = this; + } + + if ( Gwen::KeyboardFocus == this ) + { + GetCanvas()->NextTab = NULL; + } +} + +bool Base::IsChild( Controls::Base* pChild ) +{ + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + if ( pChild == (*iter) ) return true; + } + + return false; +} + +Gwen::Point Base::LocalPosToCanvas( const Gwen::Point& pnt ) +{ + if ( m_Parent ) + { + int x = pnt.x + X(); + int y = pnt.y + Y(); + + // If our parent has an innerpanel and we're a child of it + // add its offset onto us. + // + if ( m_Parent->m_InnerPanel && m_Parent->m_InnerPanel->IsChild( this ) ) + { + x += m_Parent->m_InnerPanel->X(); + y += m_Parent->m_InnerPanel->Y(); + } + + return m_Parent->LocalPosToCanvas( Gwen::Point( x, y ) ); + } + + return pnt; +} + +Gwen::Point Base::CanvasPosToLocal( const Gwen::Point& pnt ) +{ + if ( m_Parent ) + { + int x = pnt.x - X(); + int y = pnt.y - Y(); + + // If our parent has an innerpanel and we're a child of it + // add its offset onto us. + // + if ( m_Parent->m_InnerPanel && m_Parent->m_InnerPanel->IsChild( this ) ) + { + x -= m_Parent->m_InnerPanel->X(); + y -= m_Parent->m_InnerPanel->Y(); + } + + + return m_Parent->CanvasPosToLocal( Gwen::Point( x, y ) ); + } + + return pnt; +} + +bool Base::IsMenuComponent() +{ + if ( !m_Parent ) return false; + return m_Parent->IsMenuComponent(); +} + +void Base::CloseMenus() +{ + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + (*it)->CloseMenus(); + } +} + +void Base::UpdateRenderBounds() +{ + m_RenderBounds.x = 0; + m_RenderBounds.y = 0; + + m_RenderBounds.w = m_Bounds.w; + m_RenderBounds.h = m_Bounds.h; +} + +void Base::UpdateCursor() +{ + Platform::SetCursor( m_Cursor ); +} + +DragAndDrop::Package* Base::DragAndDrop_GetPackage( int /*x*/, int /*y*/ ) +{ + return m_DragAndDrop_Package; +} + +bool Base::DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ) +{ + DragAndDrop::SourceControl->SetParent( this ); + return true; +} + +bool Base::DragAndDrop_Draggable() +{ + if ( !m_DragAndDrop_Package ) return false; + + return m_DragAndDrop_Package->draggable; +} + +void Base::DragAndDrop_SetPackage( bool bDraggable, const String& strName, void* pUserData ) +{ + if ( !m_DragAndDrop_Package ) + { + m_DragAndDrop_Package = new Gwen::DragAndDrop::Package(); + } + + m_DragAndDrop_Package->draggable = bDraggable; + m_DragAndDrop_Package->name = strName; + m_DragAndDrop_Package->userdata = pUserData; +} + +void Base::DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y ) +{ + pPackage->holdoffset = CanvasPosToLocal( Gwen::Point( x, y ) ); + pPackage->drawcontrol = this; +} + +bool Base::SizeToChildren( bool w, bool h ) +{ + Gwen::Point size = ChildrenSize(); + + size.y += GetPadding().bottom; + size.x += GetPadding().right; + + return SetSize( w ? size.x : Width(), h ? size.y : Height() ); +} + +Gwen::Point Base::ChildrenSize() +{ + Gwen::Point size; + + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + if ( pChild->Hidden() ) continue; + if ( !pChild->ShouldIncludeInSize() ) continue; + + size.x = GwenUtil_Max( size.x, pChild->Right() ); + size.y = GwenUtil_Max( size.y, pChild->Bottom() ); + } + + return size; +} + +void Base::SetPadding( const Padding& padding ) +{ + if ( m_Padding.left == padding.left && + m_Padding.top == padding.top && + m_Padding.right == padding.right && + m_Padding.bottom == padding.bottom ) + return; + + m_Padding = padding; + Invalidate(); + InvalidateParent(); +} + +void Base::SetMargin( const Margin& margin ) +{ + if ( m_Margin.top == margin.top && + m_Margin.left == margin.left && + m_Margin.bottom == margin.bottom && + m_Margin.right == margin.right ) + return; + + m_Margin = margin; + Invalidate(); + InvalidateParent(); +} + +bool Base::HandleAccelerator( Gwen::String& accelerator ) +{ + if ( Gwen::KeyboardFocus == this || !AccelOnlyFocus() ) + { + AccelMap::iterator iter = m_Accelerators.find( accelerator ); + if ( iter != m_Accelerators.end() ) + { + iter->second->Call( this ); + return true; + } + } + + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + if ( (*it)->HandleAccelerator( accelerator ) ) + return true; + } + return false; +} + +bool Base::OnKeyPress( int iKey, bool bPress ) +{ + bool bHandled = false; + switch ( iKey ) + { + case Key::Tab: bHandled = OnKeyTab( bPress ); break; + case Key::Space: bHandled = OnKeySpace( bPress ); break; + case Key::Home: bHandled = OnKeyHome( bPress ); break; + case Key::End: bHandled = OnKeyEnd( bPress ); break; + case Key::Return: bHandled = OnKeyReturn( bPress ); break; + case Key::Backspace: bHandled = OnKeyBackspace( bPress ); break; + case Key::Delete: bHandled = OnKeyDelete( bPress ); break; + case Key::Right: bHandled = OnKeyRight( bPress ); break; + case Key::Left: bHandled = OnKeyLeft( bPress ); break; + case Key::Up: bHandled = OnKeyUp( bPress ); break; + case Key::Down: bHandled = OnKeyDown( bPress ); break; + case Key::Escape: bHandled = OnKeyEscape( bPress ); break; + + default: break; + } + + if ( !bHandled && GetParent() ) + GetParent()->OnKeyPress( iKey, bPress ); + + return bHandled; +} + +bool Base::OnKeyRelease( int iKey ) +{ + return OnKeyPress( iKey, false ); +} + +bool Base::OnKeyTab( bool bDown ) +{ + if ( !bDown ) return true; + + if ( GetCanvas()->NextTab ) + { + GetCanvas()->NextTab->Focus(); + Redraw(); + } + + return true; +} + +void Base::RenderFocus( Gwen::Skin::Base* skin ) +{ + if ( Gwen::KeyboardFocus != this ) return; + if ( !IsTabable() ) return; + + skin->DrawKeyboardHighlight( this, GetRenderBounds(), 3 ); +} + +void Base::SetToolTip( const TextObject& strText ) +{ + Label* tooltip = new Label( this ); + tooltip->SetText( strText ); + tooltip->SetTextColorOverride( GetSkin()->Colors.TooltipText ); + tooltip->SetPadding( Padding( 5, 3, 5, 3) ); + tooltip->SizeToContents(); + + SetToolTip( tooltip ); +} + +int Base::GetNamedChildren( Gwen::ControlList& list, const Gwen::String& strName, bool bDeep ) +{ + int iFound = 0; + + Base::List::iterator iter; + for ( iter = Children.begin(); iter != Children.end(); ++iter ) + { + Base* pChild = *iter; + if ( !pChild->GetName().empty() && pChild->GetName() == strName ) + { + list.Add( pChild ); + iFound++; + } + + if ( !bDeep ) continue; + + iFound += pChild->GetNamedChildren( list, strName, bDeep ); + } + + return iFound; +} + +Gwen::ControlList Base::GetNamedChildren( const Gwen::String& strName, bool bDeep ) +{ + Gwen::ControlList list; + GetNamedChildren( list, strName, bDeep ); + return list; +} + +#ifndef GWEN_NO_ANIMATION + +void Base::Anim_WidthIn( float fLength, float fDelay, float fEase ) +{ + Gwen::Anim::Add( this, new Gwen::Anim::Size::Width( 0, Width(), fLength, false, fDelay, fEase ) ); + SetWidth( 0 ); +} + +void Base::Anim_HeightIn( float fLength, float fDelay, float fEase ) +{ + Gwen::Anim::Add( this, new Gwen::Anim::Size::Height( 0, Height(), fLength, false, fDelay, fEase ) ); + SetHeight( 0 ); +} + +void Base::Anim_WidthOut( float fLength, bool bHide, float fDelay, float fEase ) +{ + Gwen::Anim::Add( this, new Gwen::Anim::Size::Width( Width(), 0, fLength, bHide, fDelay, fEase ) ); +} + +void Base::Anim_HeightOut( float fLength, bool bHide, float fDelay, float fEase ) +{ + Gwen::Anim::Add( this, new Gwen::Anim::Size::Height( Height(), 0, fLength, bHide, fDelay, fEase ) ); +} + +#endif \ No newline at end of file diff --git a/lib/gwen/controls/gwen_base.h b/lib/gwen/controls/gwen_base.h new file mode 100644 index 0000000..df2c3c3 --- /dev/null +++ b/lib/gwen/controls/gwen_base.h @@ -0,0 +1,556 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_BASE_H +#define GWEN_CONTROLS_BASE_H + +#include +#include +#include + +#include "../gwen_exports.h" +#include "../gwen_structures.h" +#include "../gwen_baserender.h" +#include "../gwen_events.h" +#include "../gwen_utility.h" +#include "../gwen_textobject.h" +#include "../gwen_skin.h" +#include "../gwen_controllist.h" +#include "../gwen_userdata.h" + + +namespace Gwen +{ + namespace Pos + { + enum + { + None = 0, + Left = (1 << 1), + Right = (1 << 2), + Top = (1 << 3), + Bottom = (1 << 4), + CenterV = (1 << 5), + CenterH = (1 << 6), + Fill = (1 << 7), + Center = CenterV | CenterH, + }; + } + + class TextObject; + + namespace Skin + { + class Base; + } + + namespace Controls + { + class Canvas; + + class GWEN_EXPORT Base : public Event::Handler + { + public: + + typedef stl::list List; + + typedef stl::map AccelMap; + + Base( Base* pParent, const Gwen::String& Name = "" ); + virtual ~Base(); + + virtual const char* GetTypeName(){ return "Base"; } + + virtual void DelayedDelete(); + virtual void PreDelete( Gwen::Skin::Base* skin ){}; + + virtual void SetParent( Controls::Base* pParent ); + virtual Controls::Base* GetParent() const { return m_Parent; } + virtual Controls::Canvas* GetCanvas(); + + virtual Base::List& GetChildren(){ if ( m_InnerPanel ) return m_InnerPanel->GetChildren(); return Children; } + virtual bool IsChild( Controls::Base* pChild ); + virtual unsigned int NumChildren(); + virtual Controls::Base* GetChild( unsigned int i ); + virtual bool SizeToChildren( bool w = true, bool h = true ); + virtual Gwen::Point ChildrenSize(); + virtual Controls::Base* FindChildByName( const Gwen::String& name, bool bRecursive = false ); + + template T* FindChild( const Gwen::String& name, bool bRecursive = false ); + + virtual void SetName( const Gwen::String& name) { m_Name = name; } + virtual const Gwen::String& GetName() { return m_Name; } + + virtual void Think(){} + + protected: + + virtual void AddChild( Controls::Base* pChild ); + virtual void RemoveChild( Controls::Base* pParent ); + virtual void OnChildAdded( Controls::Base* pChild ); + virtual void OnChildRemoved( Controls::Base* pChild ); + + public: + + virtual void RemoveAllChildren(); + + virtual void SendToBack( void ); + virtual void BringToFront( void ); + virtual void BringNextToControl( Controls::Base* pChild, bool bBehind ); + + virtual Gwen::Point LocalPosToCanvas( const Gwen::Point& in = Point( 0, 0 ) ); + virtual Gwen::Point CanvasPosToLocal( const Gwen::Point& in ); + + virtual void Dock( int iDock ); + virtual int GetDock(); + + virtual void RestrictToParent( bool restrict ) { m_bRestrictToParent = restrict; } + virtual bool ShouldRestrictToParent() { return m_bRestrictToParent; } + + virtual int X() const { return m_Bounds.x; } + virtual int Y() const { return m_Bounds.y; } + virtual int Width() const { return m_Bounds.w; } + virtual int Height() const { return m_Bounds.h; } + virtual int Bottom() const { return m_Bounds.y + m_Bounds.h + m_Margin.bottom; } + virtual int Right() const { return m_Bounds.x + m_Bounds.w + m_Margin.right; } + + virtual const Margin& GetMargin() const { return m_Margin; } + virtual const Padding& GetPadding() const { return m_Padding; } + + virtual void SetPos( int x, int y ); + virtual void SetPos( const Point& p ){ return SetPos( p.x, p.y ); } + virtual void SetPosInParentBounds( int x, int y ); + virtual void SetPosInParentBounds( const Point& p ){ return SetPosInParentBounds( p.x, p.y ); } + virtual Point GetPos(){ return Point( X(), Y() ); } + virtual void SetWidth( int w ) { SetSize( w, Height()); } + virtual void SetHeight( int h ) { SetSize( Width(), h); } + virtual bool SetSize( int w, int h ); + virtual bool SetSize( const Point& p ); + virtual Point GetSize(){ return Point( Width(), Height() ); } + virtual bool SetBounds( int x, int y, int w, int h ); + virtual bool SetBounds( const Gwen::Rect& bounds ); + + virtual void SetPadding( const Padding& padding ); + virtual void SetMargin( const Margin& margin ); + + // MoveTo is identical to SetPos except it uses ShouldRestrictToParent() + virtual void MoveTo (int x, int y ); + virtual void MoveBy (int x, int y ); + + virtual const Gwen::Rect& GetBounds() const { return m_Bounds; } + + virtual Controls::Base* GetControlAt( int x, int y, bool bOnlyIfMouseEnabled = true ); + + + + protected: + + virtual void OnBoundsChanged( Gwen::Rect oldBounds ); + virtual void OnChildBoundsChanged( Gwen::Rect oldChildBounds, Base* pChild ); + + virtual void OnScaleChanged(); + + public: + + // Innerbounds is the area inside the control that + // doesn't have child controls docked to it. + virtual const Gwen::Rect& GetInnerBounds() const { return m_InnerBounds; } + + protected: + + Gwen::Rect m_InnerBounds; + + public: + + virtual const Gwen::Rect& GetRenderBounds() const{ return m_RenderBounds; } + + protected: + + virtual void UpdateRenderBounds(); + + public: + + virtual void DoRender( Gwen::Skin::Base* skin ); + virtual void DoCacheRender( Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster ); + virtual void RenderRecursive( Gwen::Skin::Base* skin, const Gwen::Rect& cliprect ); + + virtual bool ShouldClip(){ return true; } + + protected: + + virtual void Render( Gwen::Skin::Base* skin ); + virtual void RenderUnder( Gwen::Skin::Base* /*skin*/ ){}; + virtual void RenderOver( Gwen::Skin::Base* /*skin*/ ){}; + virtual void RenderFocus( Gwen::Skin::Base* /*skin*/ ); + + public: + + virtual void SetHidden( bool hidden ) { if ( m_bHidden == hidden ) return; m_bHidden = hidden; Invalidate(); Redraw(); } + virtual bool Hidden() const; // Returns true only if this control is hidden + virtual bool Visible() const; // Returns false if this control or its parents are hidden + virtual void Hide(){ SetHidden( true ); } + virtual void Show(){ SetHidden( false ); } + + //Skin + virtual void SetSkin( Skin::Base* skin, bool doChildren = false ); + virtual Gwen::Skin::Base* GetSkin( void ); + + // Background drawing + virtual bool ShouldDrawBackground(){ return m_bDrawBackground; } + virtual void SetShouldDrawBackground( bool b ){ m_bDrawBackground = b; } + + protected: + + virtual void OnSkinChanged( Gwen::Skin::Base* newSkin ); + + public: + + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual bool OnMouseWheeled( int iDelta ); + virtual void OnMouseClickLeft( int /*x*/, int /*y*/, bool /*bDown*/ ){}; + virtual void OnMouseClickRight( int /*x*/, int /*y*/, bool /*bDown*/ ){} + virtual void OnMouseDoubleClickLeft( int x, int y ){ OnMouseClickLeft( x, y, true ); }; + virtual void OnMouseDoubleClickRight( int x, int y ){ OnMouseClickRight( x, y, true ); }; + virtual void OnLostKeyboardFocus(){} + virtual void OnKeyboardFocus(){} + + virtual void SetMouseInputEnabled( bool b ) { m_bMouseInputEnabled = b; } + virtual bool GetMouseInputEnabled() { return m_bMouseInputEnabled; } + + virtual void SetKeyboardInputEnabled( bool b ){ m_bKeyboardInputEnabled = b; } + virtual bool GetKeyboardInputEnabled() const { return m_bKeyboardInputEnabled; } + virtual bool NeedsInputChars(){ return false; } + + virtual bool OnChar( char /*c*/ ){ return false; } + + virtual bool OnKeyPress( int iKey, bool bPress = true ); + virtual bool OnKeyRelease( int iKey ); + + virtual void OnPaste(Controls::Base* /*pFrom*/){} + virtual void OnCopy(Controls::Base* /*pFrom*/){} + virtual void OnCut(Controls::Base* /*pFrom*/){} + virtual void OnSelectAll(Controls::Base* /*pFrom*/){} + + virtual bool OnKeyTab( bool bDown ); + virtual bool OnKeySpace( bool /*bDown*/ ){ return false; } + virtual bool OnKeyReturn( bool /*bDown*/ ){ return false; } + virtual bool OnKeyBackspace( bool /*bDown*/ ){ return false; } + virtual bool OnKeyDelete( bool /*bDown*/ ){ return false; } + virtual bool OnKeyRight( bool /*bDown*/ ){ return false; } + virtual bool OnKeyLeft( bool /*bDown*/ ){ return false; } + virtual bool OnKeyHome( bool /*bDown*/ ){ return false; } + virtual bool OnKeyEnd( bool /*bDown*/ ){ return false; } + virtual bool OnKeyUp( bool /*bDown*/ ){ return false; } + virtual bool OnKeyDown( bool /*bDown*/ ){ return false; } + virtual bool OnKeyEscape( bool /*bDown*/ ) { return false; } + + virtual void OnMouseEnter(); + virtual void OnMouseLeave(); + virtual bool IsHovered(); + virtual bool ShouldDrawHover(); + + virtual void Touch(); + virtual void OnChildTouched( Controls::Base* pChild ); + + virtual bool IsOnTop(); + + virtual bool HasFocus(); + virtual void Focus(); + virtual void Blur(); + + //Other + virtual void SetDisabled( bool active ) { if ( m_bDisabled == active ) return; m_bDisabled = active; Redraw(); } + virtual bool IsDisabled(){ return m_bDisabled; } + + virtual void Redraw(){ UpdateColours(); m_bCacheTextureDirty = true; if ( m_Parent ) m_Parent->Redraw(); } + virtual void UpdateColours(){}; + virtual void SetCacheToTexture() { m_bCacheToTexture = true; } + virtual bool ShouldCacheToTexture() { return m_bCacheToTexture; } + + virtual void SetCursor( unsigned char c ){ m_Cursor = c; } + virtual void UpdateCursor(); + + virtual Gwen::Point GetMinimumSize(){ return Gwen::Point( 1, 1 ); } + virtual Gwen::Point GetMaximumSize(){ return Gwen::Point( 4096, 4096 ); } + + virtual void SetToolTip( const Gwen::TextObject& strText ); + virtual void SetToolTip( Base* tooltip ) { m_ToolTip = tooltip; if ( m_ToolTip ){ m_ToolTip->SetParent( this ); m_ToolTip->SetHidden( true ); } } + virtual Base* GetToolTip() { return m_ToolTip; } + + virtual bool IsMenuComponent(); + virtual void CloseMenus(); + + virtual bool IsTabable() { return m_Tabable; } + virtual void SetTabable( bool isTabable ) { m_Tabable = isTabable; } + + + + + //Accelerator functionality + void DefaultAccel( Gwen::Controls::Base* /*pCtrl*/ ) { AcceleratePressed(); } + virtual void AcceleratePressed() {}; + virtual bool AccelOnlyFocus() { return false; } + virtual bool HandleAccelerator( Gwen::String& accelerator ); + + template + void AddAccelerator( const TextObject& accelerator, T func, Gwen::Event::Handler* handler = NULL ) + { + if ( handler == NULL ) + handler = this; + + Gwen::Event::Caller* caller = new Gwen::Event::Caller(); + caller->Add( handler, func ); + + Gwen::String str = accelerator.Get(); + + Gwen::Utility::Strings::ToUpper( str ); + Gwen::Utility::Strings::Strip( str, " " ); + + m_Accelerators[ str ] = caller; + } + + void AddAccelerator( const TextObject& accelerator ) + { + AddAccelerator( accelerator, &Base::DefaultAccel, this ); + } + + AccelMap m_Accelerators; + + // Default Events + + Gwen::Event::Caller onHoverEnter; + Gwen::Event::Caller onHoverLeave; + + // Childrens List + + Base::List Children; + + protected: + + // The logical parent + // It's usually what you expect, the control you've parented it to. + Base* m_Parent; + + // If the innerpanel exists our children will automatically + // become children of that instead of us - allowing us to move + // them all around by moving that panel (useful for scrolling etc) + Base* m_InnerPanel; + virtual Base* Inner(){ return m_InnerPanel; } + + // This is the panel's actual parent - most likely the logical + // parent's InnerPanel (if it has one). You should rarely need this. + Base* m_ActualParent; + + Base* m_ToolTip; + + Skin::Base* m_Skin; + + Gwen::Rect m_Bounds; + Gwen::Rect m_RenderBounds; + + Padding m_Padding; + Margin m_Margin; + + Gwen::String m_Name; + + + bool m_bRestrictToParent; + bool m_bDisabled; + bool m_bHidden; + bool m_bMouseInputEnabled; + bool m_bKeyboardInputEnabled; + bool m_bDrawBackground; + + int m_iDock; + + unsigned char m_Cursor; + + bool m_Tabable; + + public: + + bool NeedsLayout(){ return m_bNeedsLayout; } + void Invalidate(); + void InvalidateParent(){ if ( m_Parent ){ m_Parent->Invalidate(); } } + void InvalidateChildren( bool bRecursive = false ); + void Position( int pos, int xpadding = 0, int ypadding = 0 ); + + protected: + + virtual void RecurseLayout( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + virtual void PostLayout( Skin::Base* /*skin*/ ){}; + + bool m_bNeedsLayout; + bool m_bCacheTextureDirty; + bool m_bCacheToTexture; + + // + // Drag + Drop + public: + + // Giver + + virtual void DragAndDrop_SetPackage( bool bDraggable, const String& strName = "", void* pUserData = NULL ); + virtual bool DragAndDrop_Draggable(); + virtual bool DragAndDrop_ShouldStartDrag(){ return true; } + virtual void DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual Gwen::DragAndDrop::Package* DragAndDrop_GetPackage( int x, int y ); + virtual void DragAndDrop_EndDragging( bool /*bSuccess*/, int /*x*/, int /*y*/ ){}; + + protected: + + DragAndDrop::Package* m_DragAndDrop_Package; + + public: + + // Receiver + virtual void DragAndDrop_HoverEnter( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ){ } + virtual void DragAndDrop_HoverLeave( Gwen::DragAndDrop::Package* /*pPackage*/ ){ } + virtual void DragAndDrop_Hover( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ){}; + virtual bool DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual bool DragAndDrop_CanAcceptPackage( Gwen::DragAndDrop::Package* /*pPackage*/ ){ return false; } + + + // + // Useful anim shortcuts + // + public: + #ifndef GWEN_NO_ANIMATION + + virtual void Anim_WidthIn( float fLength, float fDelay = 0.0f, float fEase = 1.0f ); + virtual void Anim_HeightIn( float fLength, float fDelay = 0.0f, float fEase = 1.0f ); + virtual void Anim_WidthOut( float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f ); + virtual void Anim_HeightOut( float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f ); + + #endif + + // + // Dynamic casting, see gwen_cast below + // + public: + + static const char* GetIdentifier() + { + static const char* ident = "Base"; + return ident; + }; + + virtual Gwen::Controls::Base* DynamicCast( const char* Variable ) + { + return NULL; + } + + + public: + + void DoNotIncludeInSize(){ m_bIncludeInSize = false; } + bool ShouldIncludeInSize(){ return m_bIncludeInSize; } + + protected: + + bool m_bIncludeInSize; + + public: + + virtual void DoAction(){}; + virtual void SetAction( Event::Handler* pObject, Handler::FunctionWithInformation pFunction, const Gwen::Event::Packet& packet ){}; + + virtual int GetNamedChildren( Gwen::ControlList& list, const Gwen::String& strName, bool bDeep = true ); + virtual Gwen::ControlList GetNamedChildren( const Gwen::String& strName, bool bDeep = true ); + + public: + + UserDataStorage UserData; + + }; + + } +} +/* + To avoid using dynamic_cast we have gwen_cast. + + Each class in Gwen includes GWEN_DYNAMIC. You don't have to include this macro anywhere as it's + automatically included in the GWEN_CONTROL macro. + + GWEN_DYNAMIC adds 2 functions: + + GetIdentifier - a static function with a static variable inside, which returns + the address of the static variable. The variable is defined as a + string containing "BASECLASSNAME:CLASSNAME". This string should be + as unique as possible - or the compiler might optimize the variables + together - which means that when this function returns the address it + could be the same on one or more variables. Something to bear in mind. + + DynamicCast - non static, takes an address returned by GetIdentifier. Will return an + address of a control if the control can safely be cast to the class from + which the identifier was taken. + + Really you shouldn't actually have to concenn yourself with that stuff. The only thing you + should use in theory is gwen_cast - which is used just the same as dynamic cast - except for + one difference. We pass in the class name, not a pointer to the class. + + gwen_cast(control) + dynamic_cast(control) + +*/ + +template< class T > +T* gwen_cast( Gwen::Controls::Base* p ) +{ + if ( !p ) return NULL; + + Gwen::Controls::Base* pReturn = p->DynamicCast( T::GetIdentifier() ); + if ( !pReturn ) return NULL; + + return static_cast(pReturn); +} + + +template +T* Gwen::Controls::Base::FindChild( const Gwen::String& name, bool bRecursive ) +{ + return gwen_cast( FindChildByName( name, bRecursive ) ); +} + +#define GWEN_DYNAMIC( ThisName, BaseName ) \ + \ + static const char* GetIdentifier() \ + { \ + static const char* ident = #BaseName ":" #ThisName; \ + return ident; \ + }; \ + virtual Gwen::Controls::Base* DynamicCast( const char* Variable ) \ + { \ + if ( GetIdentifier() == Variable ) \ + return this; \ + \ + return BaseClass::DynamicCast( Variable); \ + } + +#define GWEN_CLASS( ThisName, BaseName )\ + typedef BaseName BaseClass;\ + typedef ThisName ThisClass;\ + +// To be placed in the controls .h definition. +#define GWEN_CONTROL( ThisName, BaseName )\ + public:\ + GWEN_CLASS( ThisName, BaseName )\ + GWEN_DYNAMIC( ThisName, BaseName )\ + virtual const char* GetTypeName(){ return #ThisName; }\ + virtual const char* GetBaseTypeName(){ return BaseClass::GetTypeName(); }\ + ThisName( Gwen::Controls::Base* pParent, const Gwen::String& pName = "" ) + +#define GWEN_CONTROL_INLINE( ThisName, BaseName )\ + GWEN_CONTROL( ThisName, BaseName ) : BaseClass( pParent, pName ) + +#define GWEN_CONTROL_CONSTRUCTOR( ThisName )\ + ThisName::ThisName( Gwen::Controls::Base* pParent, const Gwen::String& pName ) : BaseClass( pParent, pName ) + + + +#endif diff --git a/lib/gwen/controls/gwen_button.cpp b/lib/gwen/controls/gwen_button.cpp new file mode 100644 index 0000000..b739c80 --- /dev/null +++ b/lib/gwen/controls/gwen_button.cpp @@ -0,0 +1,286 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_button.h" +#include "gwen_imagepanel.h" +#include + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( Button ) +{ + m_Image = NULL; + m_bDepressed = false; + m_bCenterImage = false; + + SetSize( 100, 20 ); + SetMouseInputEnabled( true ); + SetIsToggle( false ); + SetAlignment( Gwen::Pos::Center ); + SetTextPadding( Padding( 3, 0, 3, 0 ) ); + m_bToggleStatus = false; + SetKeyboardInputEnabled( false ); + SetTabable( false ); +} + +void Button::Render( Skin::Base* skin ) +{ + if ( !ShouldDrawBackground() ) return; + + bool bDrawDepressed = IsDepressed() && IsHovered(); + if ( IsToggle() ) bDrawDepressed = bDrawDepressed || GetToggleState(); + + bool bDrawHovered = IsHovered() && ShouldDrawHover(); + + skin->DrawButton( this, bDrawDepressed, bDrawHovered, IsDisabled() ); +} + +void Button::OnMouseClickLeft( int /*x*/, int /*y*/, bool bDown ) +{ + if ( IsDisabled() ) return; + + if ( bDown ) + { + SetDepressed( true ); + Gwen::MouseFocus = this; + onDown.Call( this ); + } + else + { + if ( IsHovered() && m_bDepressed ) + { + OnPress(); + } + + SetDepressed( false ); + Gwen::MouseFocus = NULL; + onUp.Call( this ); + } +} + +void Button::OnMouseClickRight( int /*x*/, int /*y*/, bool bDown ) +{ + if ( IsDisabled() ) return; + + if ( bDown ) + { + SetDepressed( true ); + Gwen::MouseFocus = this; + onDown.Call( this ); + } + else + { + if ( IsHovered() && m_bDepressed ) + { + OnRightPress(); + } + + SetDepressed( false ); + Gwen::MouseFocus = NULL; + onUp.Call( this ); + } +} + + +void Button::SetDepressed( bool b ) +{ + if ( m_bDepressed == b ) return; + + m_bDepressed = b; + Redraw(); +} + +void Button::OnRightPress() +{ + onRightPress.Call( this ); +} + +void Button::OnPress() +{ + if ( IsToggle() ) + { + SetToggleState( !GetToggleState() ); + } + + onPress.Call( this ); +} + + +void Button::SetImage( const Texture& texture, bool bCenter ) +{ + if ( !m_Image ) + { + m_Image = new ImagePanel( this ); + } + + m_Image->SetImage( texture ); + m_Image->SizeToContents(); + m_Image->SetMargin( Margin( 2, 0, 2, 0 ) ); + m_bCenterImage = bCenter; + + // Ugh. + Padding padding = GetTextPadding(); + padding.left = m_Image->Right() + 2; + SetTextPadding( padding ); +} + +void Button::SetImage( const Texture& texture, float u1, float v1, float u2, float v2, bool bCenter ) +{ + if ( !m_Image ) + { + m_Image = new ImagePanel( this ); + } + + //float texCoordWidth = u2 - u1; + //float texCoordHeight = v2 - v1; + //float width = ((float)texture.width * texCoordWidth); + //float height = ((float)texture.height * texCoordHeight); + // + //// HACK: is rounding up really the best way to do this? perhaps we should + //// allow a pixel width/height to be passed in ... + //width = floorf(width + 0.5f); + //height = floorf(height + 0.5f); + + int maxWidth = Width() - 4; + int maxHeight = Height() - 4; + + m_Image->SetImage(texture); + //m_Image->SizeToContents(); + m_Image->SetSize(maxWidth, maxHeight); + m_Image->SetMargin( Margin( 2, 0, 2, 0 ) ); + m_Image->SetUV(u1, v1, u2, v2); + m_bCenterImage = bCenter; + + // Ugh. + Padding padding = GetTextPadding(); + padding.left = m_Image->Right() + 2; + SetTextPadding( padding ); +} + +void Button::SetImage( const TextObject& strName, bool bCenter ) +{ + if ( strName.Get() == "" ) + { + if ( m_Image ) + { + delete m_Image; + m_Image= NULL; + } + + return; + } + + if ( !m_Image ) + { + m_Image = new ImagePanel( this ); + } + + m_Image->SetImage( strName ); + m_Image->SizeToContents(); + m_Image->SetMargin( Margin( 2, 0, 2, 0 ) ); + m_bCenterImage = bCenter; + + // Ugh. + Padding padding = GetTextPadding(); + padding.left = m_Image->Right() + 2; + SetTextPadding( padding ); +} + +void Button::SetToggleState( bool b ) +{ + if ( m_bToggleStatus == b ) return; + + m_bToggleStatus = b; + + onToggle.Call( this ); + + if ( m_bToggleStatus ) + { + onToggleOn.Call( this ); + } + else + { + onToggleOff.Call( this ); + } + + Redraw(); +} + +void Button::SizeToContents() +{ + BaseClass::SizeToContents(); + + if ( m_Image ) + { + int height = m_Image->Height() + 4; + if ( Height() < height ) + { + SetHeight( height ); + } + } +} + +bool Button::OnKeySpace( bool bDown ) +{ + if ( bDown ) + { + OnPress(); + } + + return true; +} + +void Button::AcceleratePressed() +{ + OnPress(); +} + +void Button::UpdateColours() +{ + if ( IsDisabled() ) return SetTextColor( GetSkin()->Colors.Button.Disabled ); + if ( IsDepressed() || GetToggleState() ) return SetTextColor( GetSkin()->Colors.Button.Down ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Button.Hover ); + + SetTextColor( GetSkin()->Colors.Button.Normal ); +} + +void Button::PostLayout( Skin::Base* pSkin ) +{ + BaseClass::PostLayout( pSkin ); + + if ( m_Image ) + { + if ( m_bCenterImage ) + m_Image->Position( Pos::Center ); + else + m_Image->Position( Pos::Left | Pos::CenterV ); + } +} + +void Button::OnMouseDoubleClickLeft( int x, int y ) +{ + if ( IsDisabled() ) return; + + OnMouseClickLeft( x, y, true ); + onDoubleClick.Call( this ); +} + +void Button::SetImageAlpha( float f ) +{ + if ( !m_Image ) return; + + m_Image->SetDrawColor( Gwen::Color( 255, 255, 255, 255.0f * f ) ); +} + +void Button::SetAction( Event::Handler* pObject, Handler::FunctionWithInformation pFunction, const Gwen::Event::Packet& packet ) +{ + onPress.Add( pObject, pFunction, packet ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_button.h b/lib/gwen/controls/gwen_button.h new file mode 100644 index 0000000..0fad59f --- /dev/null +++ b/lib/gwen/controls/gwen_button.h @@ -0,0 +1,88 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_BUTTON_H +#define GWEN_CONTROLS_BUTTON_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen_texture.h" + +namespace Gwen +{ + namespace Controls + { + class ImagePanel; + + class GWEN_EXPORT Button : public Label + { + public: + + GWEN_CONTROL( Button, Label ); + + virtual void Render( Skin::Base* skin ); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + virtual void OnMouseClickRight( int x, int y, bool bDown ); + virtual void OnMouseDoubleClickLeft( int x, int y ); + virtual bool OnKeySpace( bool bDown ); + + virtual void OnPress(); + virtual void OnRightPress(); + + virtual void AcceleratePressed(); + + virtual bool IsDepressed() const { return m_bDepressed; } + virtual void SetDepressed( bool b ); + + // + // Buttons can be toggle type, which means that it is + // toggled on and off. Its toggle status is in IsDepressed. + // + virtual void SetIsToggle( bool b ){ m_bToggle = b; } + virtual bool IsToggle() const { return m_bToggle; } + virtual bool GetToggleState() const { return m_bToggleStatus; } + virtual void SetToggleState( bool b ); + virtual void Toggle(){ SetToggleState( !GetToggleState() ); } + + + virtual void SetImage( const Texture& texture, bool bCenter = false ); + virtual void SetImage( const Texture& texture, float u1, float v1, float u2, float v2, bool bCenter = false ); + virtual void SetImage( const TextObject& strName, bool bCenter = false ); + + virtual void SizeToContents(); + virtual void PostLayout( Skin::Base* pSkin ); + virtual void UpdateColours(); + + virtual void SetImageAlpha( float fMultiply ); + + virtual void DoAction(){ OnPress(); } + virtual void SetAction( Event::Handler* pObject, Handler::FunctionWithInformation pFunction, const Gwen::Event::Packet& packet ); + + public: + + Gwen::Event::Caller onPress; + Gwen::Event::Caller onRightPress; + Gwen::Event::Caller onDown; + Gwen::Event::Caller onUp; + Gwen::Event::Caller onDoubleClick; + Gwen::Event::Caller onToggle; + Gwen::Event::Caller onToggleOn; + Gwen::Event::Caller onToggleOff; + + protected: + + ImagePanel* m_Image; + + bool m_bDepressed; + bool m_bToggle; + bool m_bToggleStatus; + + bool m_bCenterImage; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_canvas.cpp b/lib/gwen/controls/gwen_canvas.cpp new file mode 100644 index 0000000..d9dffe9 --- /dev/null +++ b/lib/gwen/controls/gwen_canvas.cpp @@ -0,0 +1,243 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_canvas.h" +#include "../gwen_skin.h" +#include "gwen_menu.h" +#include "../gwen_draganddrop.h" +#include "../gwen_tooltip.h" + +#ifndef GWEN_NO_ANIMATION +#include "../gwen_anim.h" +#endif + +using namespace Gwen::Controls; + + +Canvas::Canvas( Gwen::Skin::Base* pSkin ) : BaseClass( NULL ), m_bAnyDelete( false ) +{ + SetBounds( 0, 0, 10000, 10000 ); + + SetScale( 1.0f ); + SetBackgroundColor( Color( 255, 255, 255, 255 ) ); + SetDrawBackground( false ); + + if ( pSkin ) SetSkin( pSkin ); +} + +Canvas::~Canvas() +{ + ReleaseChildren(); +} + +void Canvas::RenderCanvas() +{ + DoThink(); + + Gwen::Renderer::Base* render = m_Skin->GetRender(); + + render->Begin(); + + RecurseLayout( m_Skin ); + + render->SetClipRegion( GetBounds() ); + render->SetRenderOffset( Gwen::Point( 0, 0 ) ); + render->SetScale( Scale() ); + + if ( m_bDrawBackground ) + { + render->SetDrawColor( m_BackgroundColor ); + render->DrawFilledRect( GetRenderBounds() ); + } + + DoRender( m_Skin ); + + DragAndDrop::RenderOverlay( this, m_Skin ); + + ToolTip::RenderToolTip( m_Skin ); + + render->End(); +} + +void Canvas::Render( Gwen::Skin::Base* /*pRender*/ ) +{ + m_bNeedsRedraw = false; +} + +void Canvas::OnBoundsChanged( Gwen::Rect oldBounds ) +{ + BaseClass::OnBoundsChanged( oldBounds ); + InvalidateChildren( true ); +} + + +void Canvas::DoThink() +{ + ProcessDelayedDeletes(); + + if ( Hidden() ) return; + + #ifndef GWEN_NO_ANIMATION + Gwen::Anim::Think(); + #endif + + // Reset tabbing + { + NextTab = NULL; + FirstTab = NULL; + } + + ProcessDelayedDeletes(); + // Check has focus etc.. + RecurseLayout( m_Skin ); + + // If we didn't have a next tab, cycle to the start. + if ( NextTab == NULL ) + NextTab = FirstTab; + + Gwen::Input::OnCanvasThink( this ); + +} + +void Canvas::SetScale( float f ) +{ + if ( m_fScale == f ) return; + + m_fScale = f; + + if ( m_Skin && m_Skin->GetRender() ) + m_Skin->GetRender()->SetScale( m_fScale ); + + OnScaleChanged(); + Redraw(); +} + +void Canvas::AddDelayedDelete( Gwen::Controls::Base* pControl ) +{ + if ( !m_bAnyDelete || m_DeleteSet.find( pControl ) == m_DeleteSet.end() ) + { + m_bAnyDelete = true; + m_DeleteSet.insert( pControl ); + m_DeleteList.push_back( pControl ); + } +} + +void Canvas::PreDeleteControl( Controls::Base * pControl ) +{ + if ( m_bAnyDelete ) + { + stl::set< Controls::Base * >::iterator itFind; + if ( ( itFind = m_DeleteSet.find( pControl ) ) != m_DeleteSet.end() ) + { + m_DeleteList.remove( pControl ); + m_DeleteSet.erase( pControl ); + m_bAnyDelete = !m_DeleteSet.empty(); + } + } +} + +void Canvas::ProcessDelayedDeletes() +{ + + while( m_bAnyDelete ) + { + m_bAnyDelete = false; + + Controls::Base::List deleteList = m_DeleteList; + + m_DeleteList.clear(); + m_DeleteSet.clear(); + + for ( Gwen::Controls::Base::List::iterator it = deleteList.begin(); it != deleteList.end(); ++it ) + { + Gwen::Controls::Base* pControl = *it; + pControl->PreDelete( GetSkin() ); + delete pControl; + + Redraw(); + } + } +} + +void Canvas::ReleaseChildren() +{ + Base::List::iterator iter = Children.begin(); + while ( iter != Children.end() ) + { + Base* pChild = *iter; + iter = Children.erase( iter ); + delete pChild; + } +} + +bool Canvas::InputMouseMoved( int x, int y, int deltaX, int deltaY ) +{ + if ( Hidden() ) return false; + + if ( ToolTip::TooltipActive() ) + Redraw(); + + // Todo: Handle scaling here.. + //float fScale = 1.0f / Scale(); + + Gwen::Input::OnMouseMoved( this, x, y, deltaX, deltaY ); + + if ( !Gwen::HoveredControl ) return false; + if ( Gwen::HoveredControl == this ) return false; + if ( Gwen::HoveredControl->GetCanvas() != this ) return false; + + Gwen::HoveredControl->OnMouseMoved( x, y, deltaX, deltaY ); + Gwen::HoveredControl->UpdateCursor(); + + DragAndDrop::OnMouseMoved( Gwen::HoveredControl, x, y ); + return true; +} + +bool Canvas::InputMouseButton( int iButton, bool bDown ) +{ + if ( Hidden() ) return false; + + return Gwen::Input::OnMouseClicked( this, iButton, bDown ); +} + +bool Canvas::InputKey( int iKey, bool bDown ) +{ + if ( Hidden() ) return false; + if ( iKey <= Gwen::Key::Invalid ) return false; + if ( iKey >= Gwen::Key::Count ) return false; + + return Gwen::Input::OnKeyEvent( this, iKey, bDown ); +} + +bool Canvas::InputCharacter( char chr ) +{ + if ( Hidden() ) return false; + if ( !isprint( chr ) ) return false; + + //Handle Accelerators + if ( Gwen::Input::HandleAccelerator( this, chr ) ) + return true; + + //Handle characters + if ( !Gwen::KeyboardFocus ) return false; + if ( Gwen::KeyboardFocus->GetCanvas() != this ) return false; + if ( !Gwen::KeyboardFocus->Visible() ) return false; + if ( Gwen::Input::IsControlDown() ) return false; + + return KeyboardFocus->OnChar( chr ); +} + +bool Canvas::InputMouseWheel( int val ) +{ + if ( Hidden() ) return false; + if ( !Gwen::HoveredControl ) return false; + if ( Gwen::HoveredControl == this ) return false; + if ( Gwen::HoveredControl->GetCanvas() != this ) return false; + + return Gwen::HoveredControl->OnMouseWheeled( val ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_canvas.h b/lib/gwen/controls/gwen_canvas.h new file mode 100644 index 0000000..98aa792 --- /dev/null +++ b/lib/gwen/controls/gwen_canvas.h @@ -0,0 +1,106 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_CANVAS_H +#define GWEN_CONTROLS_CANVAS_H + +#include +#include "gwen_base.h" +#include "../gwen_inputhandler.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT Canvas : public Base + { + public: + + typedef Controls::Base BaseClass; + + Canvas( Skin::Base* pSkin ); + virtual ~Canvas(); + + // + // For additional initialization + // (which is sometimes not appropriate in the constructor) + // + virtual void Initialize(){}; + + // + // You should call this to render your canvas. + // + virtual void RenderCanvas(); + + // + // Call this whenever you want to process input. This + // is usually once a frame.. + // + virtual void DoThink(); + + // + // In most situations you will be rendering the canvas + // every frame. But in some situations you will only want + // to render when there have been changes. You can do this + // by checking NeedsRedraw(). + // + virtual bool NeedsRedraw(){ return m_bNeedsRedraw; } + virtual void Redraw(){ m_bNeedsRedraw = true; } + + // Internal. Do not call directly. + virtual void Render( Skin::Base* pRender ); + + // Childpanels call parent->GetCanvas() until they get to + // this top level function. + virtual Controls::Canvas* GetCanvas(){ return this; } + + virtual void SetScale( float f ); + virtual float Scale() const { return m_fScale; } + + virtual void OnBoundsChanged( Gwen::Rect oldBounds ); + + // Delete all children (this is done called in the destructor too) + virtual void ReleaseChildren(); + + // Delayed deletes + virtual void AddDelayedDelete( Controls::Base* pControl ); + virtual void ProcessDelayedDeletes(); + + Controls::Base* FirstTab; + Controls::Base* NextTab; + + // Input + virtual bool InputMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual bool InputMouseButton( int iButton, bool bDown ); + virtual bool InputKey( int iKey, bool bDown ); + virtual bool InputCharacter( char chr ); + virtual bool InputMouseWheel( int val ); + virtual bool InputQuit(){ return true; }; + + // Background + virtual void SetBackgroundColor( const Gwen::Color& color ){ m_BackgroundColor = color; } + virtual void SetDrawBackground( bool bShouldDraw ){ m_bDrawBackground = bShouldDraw; } + + protected: + + bool m_bNeedsRedraw; + bool m_bAnyDelete; + float m_fScale; + + Controls::Base::List m_DeleteList; + stl::set< Controls::Base* > m_DeleteSet; + friend class Controls::Base; + void PreDeleteControl( Controls::Base * ); + + bool m_bDrawBackground; + Gwen::Color m_BackgroundColor; + + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_checkbox.cpp b/lib/gwen/controls/gwen_checkbox.cpp new file mode 100644 index 0000000..2b52c83 --- /dev/null +++ b/lib/gwen/controls/gwen_checkbox.cpp @@ -0,0 +1,60 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_checkbox.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + + +GWEN_CONTROL_CONSTRUCTOR( CheckBox ) +{ + SetSize( 15, 15 ); + + m_bChecked = true; + Toggle(); +} + + +void CheckBox::Render( Skin::Base* skin ) +{ + skin->DrawCheckBox( this, m_bChecked, IsDepressed() ); +} + +void CheckBox::OnPress() +{ + if ( IsDisabled()) + return; + + if ( IsChecked() && !AllowUncheck() ) + return; + + Toggle(); +} + +void CheckBox::OnCheckStatusChanged() +{ + if ( IsChecked() ) + { + onChecked.Call( this ); + } + else + { + onUnChecked.Call( this ); + } + + onCheckChanged.Call( this ); +} + +void CheckBox::SetChecked( bool bChecked ) +{ + if ( m_bChecked == bChecked ) return; + + m_bChecked = bChecked; + OnCheckStatusChanged(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_checkbox.h b/lib/gwen/controls/gwen_checkbox.h new file mode 100644 index 0000000..e61968c --- /dev/null +++ b/lib/gwen/controls/gwen_checkbox.h @@ -0,0 +1,81 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_CHECKBOX_H +#define GWEN_CONTROLS_CHECKBOX_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_labelclickable.h" + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT CheckBox : public Button + { + public: + + GWEN_CONTROL( CheckBox, Button ); + + virtual void Render( Skin::Base* skin ); + virtual void OnPress(); + + virtual void SetChecked( bool Checked ); + virtual void Toggle() { SetChecked( !IsChecked() ); } + virtual bool IsChecked() { return m_bChecked; } + + Gwen::Event::Caller onChecked; + Gwen::Event::Caller onUnChecked; + Gwen::Event::Caller onCheckChanged; + + private: + + // For derived controls + virtual bool AllowUncheck(){ return true; } + + void OnCheckStatusChanged(); + + bool m_bChecked; + }; + + class GWEN_EXPORT CheckBoxWithLabel : public Base + { + public: + + GWEN_CONTROL_INLINE( CheckBoxWithLabel, Base ) + { + SetSize( 200, 19 ); + + m_Checkbox = new CheckBox( this ); + m_Checkbox->Dock( Pos::Left ); + m_Checkbox->SetMargin( Margin( 0, 2, 2, 2 ) ); + m_Checkbox->SetTabable( false ); + + m_Label = new LabelClickable( this ); + m_Label->Dock( Pos::Fill ); + m_Label->onPress.Add( m_Checkbox, &CheckBox::OnPress ); + m_Label->SetTabable( false ); + + SetTabable( false ); + } + + virtual CheckBox* Checkbox() { return m_Checkbox; } + virtual LabelClickable* Label() { return m_Label; } + virtual bool OnKeySpace( bool bDown ) { if ( !bDown ) m_Checkbox->SetChecked( !m_Checkbox->IsChecked() ); return true; } + + private: + + CheckBox* m_Checkbox; + LabelClickable* m_Label; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_collapsiblecategory.cpp b/lib/gwen/controls/gwen_collapsiblecategory.cpp new file mode 100644 index 0000000..6aaf8a1 --- /dev/null +++ b/lib/gwen/controls/gwen_collapsiblecategory.cpp @@ -0,0 +1,181 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#include "gwen_collapsiblecategory.h" +#include "gwen_collapsiblelist.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class CategoryButton : public Button +{ + GWEN_CONTROL_INLINE ( CategoryButton, Button ) + { + SetAlignment( Pos::Left | Pos::CenterV ); + m_bAlt = false; + } + + virtual void Render( Skin::Base* skin ) + { + if ( m_bAlt ) + { + if ( IsDepressed() || GetToggleState() ) skin->GetRender()->SetDrawColor( skin->Colors.Category.LineAlt.Button_Selected ); + else if ( IsHovered() ) skin->GetRender()->SetDrawColor( skin->Colors.Category.LineAlt.Button_Hover ); + else skin->GetRender()->SetDrawColor( skin->Colors.Category.LineAlt.Button ); + } + else + { + if ( IsDepressed() || GetToggleState() ) skin->GetRender()->SetDrawColor( skin->Colors.Category.Line.Button_Selected ); + else if ( IsHovered() ) skin->GetRender()->SetDrawColor( skin->Colors.Category.Line.Button_Hover ); + else skin->GetRender()->SetDrawColor( skin->Colors.Category.Line.Button ); + } + + skin->GetRender()->DrawFilledRect( this->GetRenderBounds() ); + } + + void UpdateColours() + { + if ( m_bAlt ) + { + if ( IsDepressed() || GetToggleState() ) return SetTextColor( GetSkin()->Colors.Category.LineAlt.Text_Selected ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Category.LineAlt.Text_Hover ); + + return SetTextColor( GetSkin()->Colors.Category.LineAlt.Text ); + } + + if ( IsDepressed() || GetToggleState() ) return SetTextColor( GetSkin()->Colors.Category.Line.Text_Selected ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Category.Line.Text_Hover ); + + return SetTextColor( GetSkin()->Colors.Category.Line.Text ); + } + + bool m_bAlt; +}; + +class CategoryHeaderButton : public Button +{ + GWEN_CONTROL_INLINE ( CategoryHeaderButton, Button ) + { + SetShouldDrawBackground( false ); + SetIsToggle( true ); + SetAlignment( Pos::Center ); + } + + void UpdateColours() + { + if ( IsDepressed() || GetToggleState() ) return SetTextColor( GetSkin()->Colors.Category.Header_Closed ); + return SetTextColor( GetSkin()->Colors.Category.Header ); + } + +}; + + +GWEN_CONTROL_CONSTRUCTOR( CollapsibleCategory ) +{ + m_pList = NULL; + + m_pButton = new CategoryHeaderButton( this ); + m_pButton->SetText( "Category Title" ); + m_pButton->Dock( Pos::Top ); + m_pButton->SetHeight( 20 ); + + SetPadding( Padding( 1, 0, 1, 5 ) ); + SetSize( 512, 512 ); +} + +Button* CollapsibleCategory::Add( const TextObject& name ) +{ + CategoryButton* pButton = new CategoryButton( this ); + pButton->SetText( name ); + pButton->Dock( Pos::Top ); + pButton->SizeToContents(); + pButton->SetSize( pButton->Width() + 4, pButton->Height() + 4 ); + pButton->SetPadding( Padding( 5, 2, 2, 2 ) ); + pButton->onPress.Add( this, &ThisClass::OnSelection ); + + return pButton; +} + +void CollapsibleCategory::OnSelection( Controls::Base* control ) +{ + CategoryButton* pChild = gwen_cast(control); + if ( !pChild ) return; + + if ( m_pList ) + { + m_pList->UnselectAll(); + } + else + { + UnselectAll(); + } + + pChild->SetToggleState( true ); + + onSelection.Call( this ); + +} + +void CollapsibleCategory::Render( Skin::Base* skin ) +{ + skin->DrawCategoryInner( this, m_pButton->GetToggleState() ); +} + +void CollapsibleCategory::SetText( const TextObject& text ) +{ + m_pButton->SetText( text ); +} + +void CollapsibleCategory::UnselectAll() +{ + Base::List& children = GetChildren(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + CategoryButton* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + pChild->SetToggleState( false ); + } +} + +void CollapsibleCategory::PostLayout( Skin::Base* /*skin*/ ) +{ + if ( m_pButton->GetToggleState() ) + { + SetHeight( m_pButton->Height() ); + } + else + { + SizeToChildren( false, true ); + } + + Base::List& children = GetChildren(); + bool b = true; + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + CategoryButton* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + pChild->m_bAlt = b; + pChild->UpdateColours(); + b = !b; + } +}; + +Button* CollapsibleCategory::GetSelected() +{ + Base::List& children = GetChildren(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + CategoryButton* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + if ( pChild->GetToggleState() ) + return pChild; + } + + return NULL; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_collapsiblecategory.h b/lib/gwen/controls/gwen_collapsiblecategory.h new file mode 100644 index 0000000..ea55312 --- /dev/null +++ b/lib/gwen/controls/gwen_collapsiblecategory.h @@ -0,0 +1,56 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_COLLAPSIBLECATEGORY_H +#define GWEN_CONTROLS_COLLAPSIBLECATEGORY_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + class CollapsibleList; + + class GWEN_EXPORT CollapsibleCategory : public Gwen::Controls::Base + { + public: + + GWEN_CONTROL( CollapsibleCategory, Gwen::Controls::Base ); + + virtual void Render( Skin::Base* skin ); + + virtual void SetText( const TextObject& text ); + + virtual Button* Add( const TextObject& name ); + + virtual void PostLayout( Skin::Base* /*skin*/ ); + + virtual void SetList( Controls::CollapsibleList* p ){ m_pList = p; } + + virtual void UnselectAll(); + virtual Button* GetSelected(); + + public: + + Gwen::Event::Caller onSelection; + + protected: + + virtual void OnSelection( Controls::Base* control ); + + Controls::Button* m_pButton; + Controls::CollapsibleList* m_pList; + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_collapsiblelist.h b/lib/gwen/controls/gwen_collapsiblelist.h new file mode 100644 index 0000000..487d28a --- /dev/null +++ b/lib/gwen/controls/gwen_collapsiblelist.h @@ -0,0 +1,105 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_COLLAPSIBLELIST_H +#define GWEN_CONTROLS_COLLAPSIBLELIST_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_scrollcontrol.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_collapsiblecategory.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT CollapsibleList : public Gwen::Controls::ScrollControl + { + public: + + Gwen::Event::Caller onSelection; + + public: + + GWEN_CONTROL_INLINE( CollapsibleList, Gwen::Controls::ScrollControl ) + { + SetScroll( false, true ); + SetAutoHideBars( true ); + } + + virtual void Add( Gwen::Controls::CollapsibleCategory* pCategory ) + { + pCategory->SetParent( this ); + pCategory->Dock( Pos::Top ); + pCategory->SetMargin( Margin( 1, 0, 1, 1 ) ); + pCategory->SetList( this ); + pCategory->onSelection.Add( this, &ThisClass::OnSelectionEvent ); + } + + virtual Gwen::Controls::CollapsibleCategory* Add( const TextObject& name ) + { + Gwen::Controls::CollapsibleCategory* pCategory = new CollapsibleCategory( this ); + pCategory->SetText( name ); + Add( pCategory ); + + return pCategory; + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawCategoryHolder( this ); + } + + virtual void UnselectAll() + { + Base::List& children = GetChildren(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + Gwen::Controls::CollapsibleCategory* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + pChild->UnselectAll(); + } + } + + virtual Gwen::Controls::Button* GetSelected() + { + Base::List& children = GetChildren(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + Gwen::Controls::CollapsibleCategory* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + Gwen::Controls::Button* pSelected = pChild->GetSelected(); + if ( pSelected ) return pSelected; + } + + return NULL; + } + + protected: + + virtual void OnSelection( Gwen::Controls::CollapsibleCategory* pControl, Gwen::Controls::Button* pSelected ) + { + onSelection.Call( this ); + } + + void OnSelectionEvent( Controls::Base* pControl ) + { + Gwen::Controls::CollapsibleCategory* pChild = gwen_cast(pControl); + if ( !pChild ) return; + + OnSelection( pChild, pChild->GetSelected() ); + } + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_colorcontrols.cpp b/lib/gwen/controls/gwen_colorcontrols.cpp new file mode 100644 index 0000000..6a6e758 --- /dev/null +++ b/lib/gwen/controls/gwen_colorcontrols.cpp @@ -0,0 +1,326 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen_utility.h" +#include "gwen_colorcontrols.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +//Find a place to put these... +Color HSVToColor( float h, float s, float v ) +{ + if (h < 0.0f) h += 360.0f; + if (h > 360.0f) h -= 360.0f; + + s *= 255.0f; + v *= 255.0f; + + float r, g, b; + + if (!h && !s) + { + r = g = b = v; + } + double min,max,delta,hue; + + max = v; + delta = (max * s)/255.0; + min = max - delta; + + hue = h; + if (h > 300 || h <= 60) + { + r = (int)max; + if (h > 300) + { + g = (int)min; + hue = (hue - 360.0)/60.0; + b = (int)((hue * delta - min) * -1); + } + else + { + b = (int)min; + hue = hue / 60.0; + g = (int)(hue * delta + min); + } + } + else if (h > 60 && h < 180) + { + g = (int)max; + if (h < 120) + { + b = (int)min; + hue = (hue/60.0 - 2.0 ) * delta; + r = (int)(min - hue); + } + else + { + r = (int)min; + hue = (hue/60 - 2.0) * delta; + b = (int)(min + hue); + } + } + else + { + b = (int)max; + if (h < 240) + { + r = (int)min; + hue = (hue/60.0 - 4.0 ) * delta; + g = (int)(min - hue); + } + else + { + g = (int)min; + hue = (hue/60 - 4.0) * delta; + r = (int)(min + hue); + } + } + + return Color( r, g, b, 255); +} + +HSV RGBtoHSV( int r, int g, int b ) +{ + double min,max,delta,temp; + min = GwenUtil_Min(r,GwenUtil_Min(g,b)); + max = GwenUtil_Max(r,GwenUtil_Max(g,b)); + delta = max - min; + + HSV hsv; + hsv.v = (int)max; + if (!delta) + { + hsv.h = hsv.s = 0; + } + else + { + temp = delta/max; + hsv.s = (int)(temp*255); + + if (r == (int)max) + { + temp = (double)(g-b)/delta; + } + else + if (g == (int)max) + { + temp = 2.0 + ((double)(b-r)/delta); + } + else + { + temp = 4.0 + ((double)(r-g)/delta); + } + temp *= 60; + if (temp < 0) + { + temp+=360; + } + if (temp == 360) + { + temp = 0; + } + hsv.h = (int)temp; + } + + + hsv.s /= 255.0f; + hsv.v /= 255.0f; + + return hsv; +} + + +GWEN_CONTROL_CONSTRUCTOR( ColorLerpBox ) +{ + SetColor( Gwen::Color(255, 128, 0, 255) ); + SetSize( 128, 128 ); + SetMouseInputEnabled( true ); + m_bDepressed = false; +} + +//Find a place to put this? color member? +Gwen::Color LerpColor( Gwen::Color &toColor, Gwen::Color &fromColor, float amount ) +{ + Gwen::Color colorDelta = toColor - fromColor; + + colorDelta.r *= amount; + colorDelta.g *= amount; + colorDelta.b *= amount; + + Gwen::Color newColor = fromColor + colorDelta; + return newColor; +} + +Gwen::Color ColorLerpBox::GetSelectedColor() +{ + return GetColorAtPos( cursorPos.x, cursorPos.y ); +} + +void ColorLerpBox::SetColor( Gwen::Color color, bool onlyHue ) +{ + HSV hsv = RGBtoHSV(color.r, color.g, color.b); + m_Hue = hsv.h; + if ( !onlyHue ) + { + cursorPos.x = hsv.s * Width(); + cursorPos.y = (1 - hsv.v) * Height(); + } + + onSelectionChanged.Call( this ); +} + +void ColorLerpBox::OnMouseMoved( int x, int y, int /*deltaX*/, int /*deltaY*/ ) +{ + if ( m_bDepressed ) + { + cursorPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + //Do we have clamp? + if ( cursorPos.x < 0) + cursorPos.x = 0; + if (cursorPos.x > Width()) + cursorPos.x = Width(); + + if (cursorPos.y < 0) + cursorPos.y = 0; + if (cursorPos.y > Height()) + cursorPos.y = Height(); + + onSelectionChanged.Call( this ); + } +} + +void ColorLerpBox::OnMouseClickLeft( int x, int y, bool bDown ) +{ + m_bDepressed = bDown; + if ( bDown ) + Gwen::MouseFocus = this; + else + Gwen::MouseFocus = NULL; + + OnMouseMoved( x, y, 0, 0); +} + +Gwen::Color ColorLerpBox::GetColorAtPos( int x, int y ) +{ + float xPercent = ( (float)x / (float)Width() ); + float yPercent = 1 - ( (float)y / (float)Height() ); + + Gwen::Color result = HSVToColor( m_Hue, xPercent, yPercent ); + + result.a = 255; + + return result; +} +void ColorLerpBox::Render( Gwen::Skin::Base* skin ) +{ + //Is there any way to move this into skin? Not for now, no idea how we'll "actually" render these + BaseClass::Render( skin ); + for ( int x = 0; xGetRender()->SetDrawColor( GetColorAtPos( x, y ) ); + skin->GetRender()->DrawPixel( x, y ); + } + } + + skin->GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + skin->GetRender()->DrawLinedRect( GetRenderBounds() ); + + Gwen::Color selected = GetSelectedColor(); + if ( (selected.r + selected.g + selected.b) / 3 < 170 ) + skin->GetRender()->SetDrawColor( Gwen::Color( 255, 255, 255, 255 ) ); + else + skin->GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + + Gwen::Rect testRect = Gwen::Rect( cursorPos.x -3, cursorPos.y -3, 6, 6); + + skin->GetRender()->DrawShavedCornerRect( testRect ); +} + + + + + +GWEN_CONTROL_CONSTRUCTOR( ColorSlider ) +{ + SetSize( 32, 128 ); + SetMouseInputEnabled( true ); + m_bDepressed = false; +} + +void ColorSlider::Render( Gwen::Skin::Base* skin ) +{ + //Is there any way to move this into skin? Not for now, no idea how we'll "actually" render these + int y = 0; + for ( y = 0; y < Height(); y++) + { + float yPercent = (float)y / (float)Height(); + skin->GetRender()->SetDrawColor( HSVToColor( yPercent * 360, 1, 1 ) ); + skin->GetRender()->DrawFilledRect( Gwen::Rect( 5, y, Width() - 10, 1 ) ); + } + + int drawHeight = m_iSelectedDist - 3; + + //Draw our selectors + skin->GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 )); + skin->GetRender()->DrawFilledRect( Gwen::Rect( 0, drawHeight + 2, Width(), 1)); + skin->GetRender()->DrawFilledRect( Gwen::Rect( 0, drawHeight, 5, 5) ); + skin->GetRender()->DrawFilledRect( Gwen::Rect( Width() - 5, drawHeight, 5, 5) ); + skin->GetRender()->SetDrawColor( Gwen::Color( 255, 255, 255, 255 ) ); + skin->GetRender()->DrawFilledRect( Gwen::Rect( 1, drawHeight + 1, 3, 3 ) ); + skin->GetRender()->DrawFilledRect( Gwen::Rect( Width() - 4, drawHeight + 1, 3, 3 ) ); +} + +void ColorSlider::OnMouseClickLeft( int x, int y, bool bDown ) +{ + m_bDepressed = bDown; + if ( bDown) + Gwen::MouseFocus = this; + else + Gwen::MouseFocus = NULL; + + OnMouseMoved(x, y, 0, 0); +} + +Gwen::Color ColorSlider::GetColorAtHeight( int y ) +{ + float yPercent = (float)y / (float)Height(); + return HSVToColor( yPercent * 360, 1, 1); + +} +void ColorSlider::OnMouseMoved( int x, int y, int /*deltaX*/, int /*deltaY*/ ) +{ + if ( m_bDepressed ) + { + Gwen::Point cursorPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + + if (cursorPos.y < 0) + cursorPos.y = 0; + if (cursorPos.y > Height()) + cursorPos.y = Height(); + + m_iSelectedDist = cursorPos.y; + onSelectionChanged.Call( this ); + } +} + +void ColorSlider::SetColor( Gwen::Color color) +{ + HSV hsv = RGBtoHSV( color.r, color.g, color.b ); + + m_iSelectedDist = hsv.h / 360 * Height(); + + onSelectionChanged.Call( this ); +} + +Gwen::Color ColorSlider::GetSelectedColor() +{ + return GetColorAtHeight( m_iSelectedDist ); +} diff --git a/lib/gwen/controls/gwen_colorcontrols.h b/lib/gwen/controls/gwen_colorcontrols.h new file mode 100644 index 0000000..1d29faf --- /dev/null +++ b/lib/gwen/controls/gwen_colorcontrols.h @@ -0,0 +1,61 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_COLORCONTROLS_H +#define GWEN_CONTROLS_COLORCONTROLS_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT ColorLerpBox : public Controls::Base + { + public: + GWEN_CONTROL( ColorLerpBox, Controls::Base ); + virtual void Render( Gwen::Skin::Base* skin ); + Gwen::Color GetColorAtPos(int x, int y ); + void SetColor( Gwen::Color color, bool onlyHue = true ); + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + Gwen::Color GetSelectedColor(); + + Event::Caller onSelectionChanged; + protected: + Gwen::Point cursorPos; + bool m_bDepressed; + int m_Hue; + + }; + + class GWEN_EXPORT ColorSlider : public Controls::Base + { + public: + GWEN_CONTROL( ColorSlider, Controls::Base ); + virtual void Render( Gwen::Skin::Base* skin ); + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + Gwen::Color GetSelectedColor(); + Gwen::Color GetColorAtHeight(int y ); + void SetColor( Gwen::Color color ); + + Event::Caller onSelectionChanged; + + protected: + int m_iSelectedDist; + bool m_bDepressed; + + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_colorpicker.cpp b/lib/gwen/controls/gwen_colorpicker.cpp new file mode 100644 index 0000000..8d5d116 --- /dev/null +++ b/lib/gwen/controls/gwen_colorpicker.cpp @@ -0,0 +1,218 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_colorpicker.h" +#include "gwen_horizontalslider.h" +#include "gwen_groupbox.h" +#include "gwen_textbox.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +GWEN_CONTROL_CONSTRUCTOR( ColorPicker ) +{ + SetMouseInputEnabled( true ); + + SetSize( 256, 150 ); + CreateControls(); + SetColor( Gwen::Color( 50, 60, 70, 255 ) ); +} + +void ColorPicker::CreateColorControl( Gwen::String name, int y ) +{ + int colorSize = 12; + + GroupBox* colorGroup = new GroupBox( this ); + colorGroup->SetPos( 10, y ); + colorGroup->SetText( name ); + colorGroup->SetSize( 160, 35 ); + colorGroup->SetName( name + "groupbox" ); + + ColorDisplay* disp = new ColorDisplay( colorGroup ); + disp->SetName(name); + disp->SetBounds( 0 , 10, colorSize, colorSize ); + + TextBoxNumeric* numeric = new TextBoxNumeric( colorGroup ); + numeric->SetName( name + "Box" ); + numeric->SetPos( 105, 7 ); + numeric->SetSize( 26, 16 ); + numeric->SetSelectAllOnFocus( true ); + numeric->onTextChanged.Add( this, &ColorPicker::NumericTyped ); + + HorizontalSlider* slider = new HorizontalSlider( colorGroup ); + slider->SetPos( colorSize + 5 , 8 ); + slider->SetRange( 0, 255 ); + slider->SetSize( 80, Gwen::Utility::Max( colorSize, 15 ) ); + slider->SetName( name + "Slider"); + slider->onValueChanged.Add( this, &ColorPicker::SlidersMoved ); +} + +void ColorPicker::NumericTyped( Gwen::Controls::Base* control ) +{ + TextBoxNumeric* box = gwen_cast(control); + if (!box) + return; + + if ( box->GetText() == "") + return; + + int textValue = atoi( box->GetText().c_str() ); + if ( textValue < 0) textValue = 0; + if ( textValue > 255) textValue = 255; + + if ( box->GetName().find("Red") != Gwen::String::npos ) + SetRed( textValue ); + + if ( box->GetName().find("Green") != Gwen::String::npos ) + SetGreen( textValue ); + + if ( box->GetName().find("Blue") != Gwen::String::npos ) + SetBlue( textValue ); + + if ( box->GetName().find("Alpha") != Gwen::String::npos ) + SetAlpha( textValue ); + + UpdateControls(); +} + +void ColorPicker::SetColor( Gwen::Color color ) +{ + m_Color = color; + UpdateControls(); +} + +void ColorPicker::CreateControls() +{ + int startY = 5; + int height = 35; + + CreateColorControl( "Red", startY ); + CreateColorControl( "Green", startY + height ); + CreateColorControl( "Blue", startY + height * 2 ); + CreateColorControl( "Alpha", startY + height * 3 ); + + GroupBox* finalGroup = new GroupBox( this ); + finalGroup->SetPos( 180, 40 ); + finalGroup->SetSize( 60, 60 ); + finalGroup->SetText( "Result" ); + finalGroup->SetName( "ResultGroupBox" ); + + + ColorDisplay* disp = new ColorDisplay( finalGroup ); + disp->SetName( "Result" ); + disp->SetBounds( 0 , 10, 32, 32 ); + disp->SetDrawCheckers( true ); + + //UpdateControls(); +} + +void ColorPicker::UpdateColorControls( Gwen::String name, Gwen::Color col, int sliderVal ) +{ + ColorDisplay* disp = gwen_cast(FindChildByName( name, true ) ); + disp->SetColor( col ); + + HorizontalSlider* slider = gwen_cast( FindChildByName( name + "Slider", true ) ); + slider->SetFloatValue( sliderVal ); + + TextBoxNumeric* box = gwen_cast( FindChildByName( name + "Box", true ) ); + box->SetText( Gwen::Utility::ToString( sliderVal ) ); +} + +void ColorPicker::UpdateControls() +{ + + //This is a little weird, but whatever for now + UpdateColorControls( "Red", Color( GetColor().r, 0, 0, 255 ), GetColor().r ); + UpdateColorControls( "Green", Color( 0, GetColor().g, 0, 255 ), GetColor().g ); + UpdateColorControls( "Blue", Color( 0, 0, GetColor().b, 255 ), GetColor().b ); + UpdateColorControls( "Alpha", Color( 255, 255, 255, GetColor().a ), GetColor().a ); + + ColorDisplay* disp = gwen_cast( FindChildByName( "Result", true ) ); + disp->SetColor( Color( GetColor().r, GetColor().g, GetColor().b, GetColor().a ) ); + + onColorChanged.Call( this ); +} +void ColorPicker::SlidersMoved( Gwen::Controls::Base* control ) +{ + /* + HorizontalSlider* redSlider = gwen_cast( FindChildByName( "RedSlider", true ) ); + HorizontalSlider* greenSlider = gwen_cast( FindChildByName( "GreenSlider", true ) ); + HorizontalSlider* blueSlider = gwen_cast( FindChildByName( "BlueSlider", true ) ); + HorizontalSlider* alphaSlider = gwen_cast( FindChildByName( "AlphaSlider", true ) ); + */ + + HorizontalSlider* slider = gwen_cast( control ); + if (slider) + SetColorByName( GetColorFromName( slider->GetName() ), slider->GetFloatValue() ); + + UpdateControls(); + //SetColor( Gwen::Color( redSlider->GetValue(), greenSlider->GetValue(), blueSlider->GetValue(), alphaSlider->GetValue() ) ); +} + +void ColorPicker::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + SizeToChildren( false, true ); + SetSize( Width(), Height() + 5 ); + + GroupBox* groupBox = gwen_cast(FindChildByName( "ResultGroupBox", true ) ); + if ( groupBox ) + groupBox->SetPos( groupBox->X(), Height() * 0.5f - groupBox->Height() * 0.5f ); + + UpdateControls(); +} + + +int ColorPicker::GetColorByName( Gwen::String colorName ) +{ + if ( colorName == "Red") + return GetColor().r; + else if ( colorName == "Green") + return GetColor().g; + else if ( colorName == "Blue") + return GetColor().b; + else if ( colorName == "Alpha") + return GetColor().a; + else + return 0; +} + +Gwen::String ColorPicker::GetColorFromName( Gwen::String name ) +{ + if ( name.find("Red") != Gwen::String::npos ) + return "Red"; + if ( name.find("Green") != Gwen::String::npos ) + return "Green"; + if ( name.find("Blue") != Gwen::String::npos ) + return "Blue"; + if ( name.find("Alpha") != Gwen::String::npos ) + return "Alpha"; + else + return ""; +} + +void ColorPicker::SetColorByName( Gwen::String colorName, int colorValue ) +{ + if ( colorName == "Red") + SetRed( colorValue ); + else if ( colorName == "Green") + SetGreen( colorValue ); + else if ( colorName == "Blue") + SetBlue( colorValue ); + else if ( colorName == "Alpha") + SetAlpha( colorValue ); +} + +void ColorPicker::SetAlphaVisible( bool visible ) +{ + GroupBox* groupBox = gwen_cast(FindChildByName( "Alphagroupbox", true ) ); + groupBox->SetHidden( !visible ); + Invalidate(); +} diff --git a/lib/gwen/controls/gwen_colorpicker.h b/lib/gwen/controls/gwen_colorpicker.h new file mode 100644 index 0000000..34091e7 --- /dev/null +++ b/lib/gwen/controls/gwen_colorpicker.h @@ -0,0 +1,88 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_COLORPICKER_H +#define GWEN_CONTROLS_COLORPICKER_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT ColorDisplay : public Controls::Base + { + public: + GWEN_CONTROL_INLINE( ColorDisplay, Controls::Base ) + { + SetSize( 32, 32 ); + m_Color = Color( 255, 0, 0, 255 ); + m_DrawCheckers = true; + } + + virtual void Render( Gwen::Skin::Base* skin ) + { + skin->DrawColorDisplay( this, m_Color ); + } + + virtual void SetColor( Gwen::Color color ) { m_Color = color; } + virtual Gwen::Color GetColor() { return m_Color; } + + virtual void SetRed( int red ) { m_Color.r = red; } + virtual void SetGreen( int green ) { m_Color.g = green;} + virtual void SetBlue( int blue ) { m_Color.b = blue; } + virtual void SetAlpha( int alpha ) { m_Color.a = alpha;} + + virtual void SetDrawCheckers( bool should ) { m_DrawCheckers = should; } + + protected: + Gwen::Color m_Color; + bool m_DrawCheckers; + }; + } + namespace Controls + { + + class GWEN_EXPORT ColorPicker : public Base + { + public: + + GWEN_CONTROL( ColorPicker, Base ); + + virtual void Layout( Skin::Base* skin ); + virtual void CreateControls(); + virtual void SlidersMoved( Gwen::Controls::Base* control ); + virtual void NumericTyped( Gwen::Controls::Base* control ); + virtual void UpdateControls(); + virtual void UpdateColorControls( Gwen::String name, Gwen::Color col, int sliderVal ); + virtual void CreateColorControl( Gwen::String name, int y ); + + virtual void SetColor( Gwen::Color color ); + virtual Gwen::Color GetColor() { return m_Color; } + + int GetColorByName( Gwen::String colorName ); + void SetColorByName( Gwen::String colorName, int colorValue ); + Gwen::String GetColorFromName( Gwen::String name ); + virtual void SetAlphaVisible( bool visible ); + + virtual void SetRed( int red ) { m_Color.r = red; } + virtual void SetGreen( int green ) { m_Color.g = green;} + virtual void SetBlue( int blue ) { m_Color.b = blue; } + virtual void SetAlpha( int alpha ) { m_Color.a = alpha;} + + Event::Caller onColorChanged; + + protected: + Gwen::Color m_Color; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_combobox.cpp b/lib/gwen/controls/gwen_combobox.cpp new file mode 100644 index 0000000..7935fe3 --- /dev/null +++ b/lib/gwen/controls/gwen_combobox.cpp @@ -0,0 +1,250 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_combobox.h" +#include "gwen_menu.h" + + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +class GWEN_EXPORT DownArrow : public Controls::Base +{ + public: + + GWEN_CONTROL_INLINE( DownArrow, Controls::Base ) + { + SetMouseInputEnabled( false ); + SetSize( 15, 15 ); + } + + void Render( Skin::Base* skin ) + { + if ( !m_ComboBox->ShouldDrawBackground() ) + { + return skin->DrawComboDownArrow( this, false, false, false, m_ComboBox->IsDisabled() ); + } + + skin->DrawComboDownArrow( this, m_ComboBox->IsHovered(), m_ComboBox->IsDepressed(), m_ComboBox->IsMenuOpen(), m_ComboBox->IsDisabled() ); + } + + void SetComboBox( ComboBox* p ){ m_ComboBox = p; } + + protected: + + ComboBox* m_ComboBox; +}; + +GWEN_CONTROL_CONSTRUCTOR( ComboBox ) +{ + SetSize( 100, 20 ); + + m_Menu = new Menu( this ); + m_Menu->SetHidden( true ); + m_Menu->SetDisableIconMargin( true ); + m_Menu->SetTabable( false ); + + DownArrow* pArrow = new DownArrow( this ); + pArrow->SetComboBox( this ); + m_Button = pArrow; + + m_SelectedItem = NULL; + + SetAlignment( Gwen::Pos::Left | Gwen::Pos::CenterV ); + SetText( "" ); + SetMargin( Margin( 3, 0, 0, 0 ) ); + + SetTabable( true ); + SetKeyboardInputEnabled( true ); + +} + +MenuItem* ComboBox::AddItem( const String& strLabel, const String& strName ) +{ + MenuItem* pItem = m_Menu->AddItem( strLabel, "" ); + pItem->SetName( strName ); + + pItem->onMenuItemSelected.Add( this, &ComboBox::OnItemSelected ); + + //Default + if ( m_SelectedItem == NULL ) + OnItemSelected( pItem ); + + return pItem; +} + +void ComboBox::Render( Skin::Base* skin ) +{ + if ( !ShouldDrawBackground() ) return; + + skin->DrawComboBox( this, IsDepressed(), IsMenuOpen()); +} + +void ComboBox::Layout( Skin::Base* skin ) +{ + m_Button->Position( Pos::Right | Pos::CenterV, 4, 0 ); + + BaseClass::Layout( skin ); +} + +void ComboBox::UpdateColours() +{ + if ( !ShouldDrawBackground() ) + { + return SetTextColor( GetSkin()->Colors.Button.Normal ); + } + + BaseClass::UpdateColours(); +} + +void ComboBox::OnPress() +{ + if ( IsMenuOpen() ) + { + return GetCanvas()->CloseMenus(); + } + + bool bWasMenuHidden = m_Menu->Hidden(); + + GetCanvas()->CloseMenus(); + + if ( bWasMenuHidden ) + { + OpenList(); + } +} + +void ComboBox::ClearItems() +{ + if ( m_Menu ) + { + m_Menu->ClearItems(); + } +} + +void ComboBox::SelectItem( MenuItem* pItem ) +{ + if ( m_SelectedItem == pItem ) return; + + m_SelectedItem = pItem; + SetText( m_SelectedItem->GetText() ); + m_Menu->SetHidden( true ); + Invalidate(); +} + +void ComboBox::OnItemSelected( Controls::Base* pControl ) +{ + //Convert selected to a menu item + MenuItem* pItem = gwen_cast( pControl ); + if ( !pItem ) return; + + SelectItem( pItem ); + + onSelection.Call( this ); + Focus(); +} + +void ComboBox::SelectItemByName( const Gwen::String& name, bool bFireChangeEvents ) +{ + Base::List& children = m_Menu->GetChildren(); + Base::List::iterator it = children.begin(); + + while ( it != children.end() ) + { + MenuItem* pChild = gwen_cast( *it ); + + if ( pChild->GetName() == name ) + { + if ( bFireChangeEvents ) + return OnItemSelected( pChild ); + + return SelectItem( pChild ); + } + + ++it; + } +} + +void ComboBox::OnLostKeyboardFocus() +{ + SetTextColor( Color( 0, 0, 0, 255 ) ); +} + + +void ComboBox::OnKeyboardFocus() +{ + //Until we add the blue highlighting again + SetTextColor( Color( 0, 0, 0, 255 ) ); + //m_SelectedText->SetTextColor( Color( 255, 255, 255, 255 ) ); +} + +Gwen::Controls::Label* ComboBox::GetSelectedItem() +{ + return m_SelectedItem; +} + +bool ComboBox::IsMenuOpen() +{ + return m_Menu && !m_Menu->Hidden(); +} + +void ComboBox::OpenList() +{ + if ( !m_Menu ) return; + + m_Menu->SetParent( GetCanvas() ); + m_Menu->SetHidden( false ); + m_Menu->BringToFront(); + + Gwen::Point p = LocalPosToCanvas( Gwen::Point( 0, 0 ) ); + + m_Menu->SetBounds( Gwen::Rect ( p.x, p.y + Height(), Width(), m_Menu->Height()) ); +} + +void ComboBox::CloseList() +{ + if ( !m_Menu ) return; + + m_Menu->Hide(); +} + + +bool ComboBox::OnKeyUp( bool bDown ) +{ + if ( bDown ) + { + Base::List& children = m_Menu->GetChildren(); + + Base::List::reverse_iterator it = stl::find( children.rbegin(), children.rend(), m_SelectedItem ); + if ( it != children.rend() && ( ++it != children.rend() ) ) + { + Base* pUpElement = *it; + OnItemSelected( pUpElement ); + } + } + return true; +} +bool ComboBox::OnKeyDown( bool bDown ) +{ + if ( bDown ) + { + Base::List& children = m_Menu->GetChildren(); + + Base::List::iterator it = stl::find( children.begin(), children.end(), m_SelectedItem ); + if ( it != children.end() && ( ++it != children.end() ) ) + { + Base* pDownElement = *it; + OnItemSelected( pDownElement ); + } + } + return true; +} + +void ComboBox::RenderFocus( Gwen::Skin::Base* /*skin*/ ) +{ +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_combobox.h b/lib/gwen/controls/gwen_combobox.h new file mode 100644 index 0000000..43137b9 --- /dev/null +++ b/lib/gwen/controls/gwen_combobox.h @@ -0,0 +1,70 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_COMBOBOX_H +#define GWEN_CONTROLS_COMBOBOX_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_textbox.h" +#include "gwen_menu.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT ComboBox : public Button + { + public: + + GWEN_CONTROL( ComboBox, Button ); + + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + virtual void UpdateColours(); + + virtual void SelectItemByName( const Gwen::String& name, bool bFireChangeEvents = true ); + virtual Gwen::Controls::Label* GetSelectedItem(); + + virtual void OnPress(); + virtual void OnItemSelected( Controls::Base* pControl ); + virtual void OpenList(); + virtual void CloseList(); + + virtual void ClearItems(); + + virtual MenuItem* AddItem( const String& strLabel, const String& strName = "" ); + virtual bool OnKeyUp( bool bDown ); + virtual bool OnKeyDown( bool bDown ); + + virtual void RenderFocus( Gwen::Skin::Base* skin ); + virtual void OnLostKeyboardFocus(); + virtual void OnKeyboardFocus(); + + virtual bool IsMenuOpen(); + + virtual bool IsMenuComponent(){ return true; } + + Gwen::Event::Caller onSelection; + + protected: + + void SelectItem( MenuItem* pItem ); + + Menu* m_Menu; + MenuItem* m_SelectedItem; + + Controls::Base* m_Button; + + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_crosssplitter.cpp b/lib/gwen/controls/gwen_crosssplitter.cpp new file mode 100644 index 0000000..3a0ab09 --- /dev/null +++ b/lib/gwen/controls/gwen_crosssplitter.cpp @@ -0,0 +1,182 @@ + +#include "../gwen.h" +#include "gwen_crosssplitter.h" +#include "gwen_button.h" + +using namespace Gwen; +using namespace Controls; + +GWEN_CONTROL_CONSTRUCTOR( CrossSplitter ) +{ + m_VSplitter = new SplitterBar( this ); + m_VSplitter->SetPos( 0, 128 ); + m_VSplitter->onDragged.Add( this, &CrossSplitter::OnVerticalMoved ); + m_VSplitter->SetCursor( Gwen::CursorType::SizeNS ); + + m_HSplitter = new SplitterBar( this ); + m_HSplitter->SetPos( 128, 0 ); + m_HSplitter->onDragged.Add( this, &CrossSplitter::OnHorizontalMoved ); + m_HSplitter->SetCursor( Gwen::CursorType::SizeWE ); + + m_CSplitter = new SplitterBar( this ); + m_CSplitter->SetPos( 128, 128 ); + m_CSplitter->onDragged.Add( this, &CrossSplitter::OnCenterMoved ); + m_CSplitter->SetCursor( Gwen::CursorType::SizeAll ); + + m_fHVal = 0.5f; + m_fVVal = 0.5f; + + SetPanel( 0, NULL ); + SetPanel( 1, NULL ); + SetPanel( 2, NULL ); + SetPanel( 3, NULL ); + + SetSplitterSize( 5 ); + + m_iZoomedSection = -1; +} + +void CrossSplitter::UpdateVSplitter() +{ + m_VSplitter->MoveTo( m_VSplitter->X(), ( Height() - m_VSplitter->Height() ) * ( m_fVVal )); +} +void CrossSplitter::UpdateHSplitter() +{ + m_HSplitter->MoveTo( ( Width() - m_HSplitter->Width() ) * ( m_fHVal ), m_HSplitter->Y() ); +} + +void CrossSplitter::OnCenterMoved( Controls::Base * /*control*/ ) +{ + //Move the other two bars into position + CalculateValueCenter(); + Invalidate(); +} + +void CrossSplitter::UpdateCSplitter() +{ + m_CSplitter->MoveTo( ( Width() - m_CSplitter->Width() ) * ( m_fHVal ), ( Height() - m_CSplitter->Height() ) * ( m_fVVal )); +} + +void CrossSplitter::OnHorizontalMoved( Controls::Base * /*control*/ ) +{ + m_fHVal = CalculateValueHorizontal(); + Invalidate(); +} +void CrossSplitter::OnVerticalMoved( Controls::Base * /*control*/ ) +{ + m_fVVal = CalculateValueVertical(); + Invalidate(); +} + +void CrossSplitter::CalculateValueCenter() +{ + m_fHVal = (float)m_CSplitter->X() / (float)( Width() - m_CSplitter->Width() ); + m_fVVal = (float)m_CSplitter->Y() / (float)( Height() - m_CSplitter->Height() ); +} + +float CrossSplitter::CalculateValueHorizontal() +{ + return (float)m_HSplitter->X() / (float)( Width() - m_HSplitter->Width() ); +} + +float CrossSplitter::CalculateValueVertical() +{ + return (float)m_VSplitter->Y() / (float)( Height() - m_VSplitter->Height() ); +} + +void CrossSplitter::Layout( Skin::Base* /*skin*/ ) +{ + m_VSplitter->SetSize( Width(), m_fBarSize ); + m_HSplitter->SetSize( m_fBarSize, Height() ); + m_CSplitter->SetSize( m_fBarSize, m_fBarSize ); + + UpdateVSplitter(); + UpdateHSplitter(); + UpdateCSplitter(); + + if ( m_iZoomedSection == -1 ) + { + if ( m_Sections[0] ) + m_Sections[0]->SetBounds( 0, 0, m_HSplitter->X(), m_VSplitter->Y() ); + + if ( m_Sections[1] ) + m_Sections[1]->SetBounds( m_HSplitter->X() + m_fBarSize, 0, Width() - ( m_HSplitter->X() + m_fBarSize ), m_VSplitter->Y() ); + + if ( m_Sections[2] ) + m_Sections[2]->SetBounds( 0, m_VSplitter->Y() + m_fBarSize, m_HSplitter->X(), Height() - ( m_VSplitter->Y() + m_fBarSize ) ); + + if ( m_Sections[3] ) + m_Sections[3]->SetBounds( m_HSplitter->X() + m_fBarSize, m_VSplitter->Y() + m_fBarSize, Width() - ( m_HSplitter->X() + m_fBarSize ), Height() - ( m_VSplitter->Y() + m_fBarSize ) ); + } + else + { + //This should probably use Fill docking instead + m_Sections[(int)m_iZoomedSection]->SetBounds( 0, 0, Width(), Height() ); + } +} + +void CrossSplitter::SetPanel( int index, Controls::Base* pPanel) +{ + Debug::AssertCheck( index >= 0 && index <= 3, "CrossSplitter::SetPanel out of range" ); + + m_Sections[index] = pPanel; + + if ( pPanel ) + { + pPanel->Dock( Pos::None ); + pPanel->SetParent( this ); + } + + Invalidate(); +} + +Controls::Base* CrossSplitter::GetPanel( int i ) +{ + return m_Sections[i]; +} + + +void CrossSplitter::ZoomChanged() +{ + onZoomChange.Call( this ); + if ( m_iZoomedSection == -1 ) + { + onUnZoomed.Call( this ); + } + else + { + onZoomed.Call( this ); + } +} + +void CrossSplitter::Zoom( int section ) +{ + UnZoom(); + + if ( m_Sections[section] ) + { + for (int i = 0; i < 4; i++) + { + if ( i != section && m_Sections[i] ) + m_Sections[i]->SetHidden( true ); + } + m_iZoomedSection = section; + + Invalidate(); + } + ZoomChanged(); +} + +void CrossSplitter::UnZoom() +{ + m_iZoomedSection = -1; + + for ( int i = 0; i < 4; i++ ) + { + if ( m_Sections[i] ) + m_Sections[i]->SetHidden( false ); + } + + Invalidate(); + ZoomChanged(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_crosssplitter.h b/lib/gwen/controls/gwen_crosssplitter.h new file mode 100644 index 0000000..9a2afa8 --- /dev/null +++ b/lib/gwen/controls/gwen_crosssplitter.h @@ -0,0 +1,62 @@ +#pragma once +#ifndef GWEN_CONTROLS_CROSSSPLITTER_H +#define GWEN_CONTROLS_CROSSSPLITTER_H + +#include "../gwen.h" +#include "gwen_base.h" +#include "gwen_splitterbar.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT CrossSplitter : public Controls::Base + { + public: + + GWEN_CONTROL( CrossSplitter, Controls::Base ); + + void Layout( Skin::Base* skin ); + + virtual float CalculateValueVertical(); + virtual float CalculateValueHorizontal(); + virtual void CalculateValueCenter(); + virtual void UpdateHSplitter(); + virtual void UpdateVSplitter(); + virtual void UpdateCSplitter(); + virtual void OnVerticalMoved( Controls::Base * control ); + virtual void OnHorizontalMoved( Controls::Base * control ); + virtual void OnCenterMoved( Controls::Base * control ); + + virtual void SetPanel( int i, Controls::Base* pPanel ); + virtual Controls::Base* GetPanel( int i ); + + virtual bool IsZoomed(){ return m_iZoomedSection != -1; } + virtual void Zoom( int section ); + virtual void UnZoom(); + virtual void ZoomChanged(); + virtual void CenterPanels() { m_fHVal = 0.5f; m_fVVal = 0.5f; Invalidate(); } + + virtual void SetSplitterSize( int size ) { m_fBarSize = size; } + + private: + + SplitterBar* m_VSplitter; + SplitterBar* m_HSplitter; + SplitterBar* m_CSplitter; + + Controls::Base* m_Sections[4]; + + float m_fHVal; + float m_fVVal; + int m_fBarSize; + + int m_iZoomedSection; + + Gwen::Event::Caller onZoomed; + Gwen::Event::Caller onUnZoomed; + Gwen::Event::Caller onZoomChange; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_dockbase.cpp b/lib/gwen/controls/gwen_dockbase.cpp new file mode 100644 index 0000000..af4a475 --- /dev/null +++ b/lib/gwen/controls/gwen_dockbase.cpp @@ -0,0 +1,338 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_dockbase.h" +#include "gwen_dockedtabcontrol.h" +#include "gwen_highlight.h" +#include "../gwen_draganddrop.h" +#include "gwen_resizer.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( DockBase ) +{ + SetPadding( Padding( 1, 1, 1, 1 ) ); + SetSize( 200, 200 ); + + m_DockedTabControl = NULL; + m_Left = NULL; + m_Right = NULL; + m_Top = NULL; + m_Bottom = NULL; + + m_bDrawHover = false; +} + +TabControl* DockBase::GetTabControl() +{ + return m_DockedTabControl; +} + +void DockBase::SetupChildDock( int iPos ) +{ + if ( !m_DockedTabControl ) + { + m_DockedTabControl = new DockedTabControl( this ); + m_DockedTabControl->onLoseTab.Add( this, &DockBase::OnTabRemoved ); + m_DockedTabControl->SetTabStripPosition( Pos::Bottom ); + m_DockedTabControl->SetShowTitlebar( true ); + } + + Dock( iPos ); + + int iSizeDirection = Pos::Left; + if ( iPos == Pos::Left ) iSizeDirection = Pos::Right; + if ( iPos == Pos::Top ) iSizeDirection = Pos::Bottom; + if ( iPos == Pos::Bottom ) iSizeDirection = Pos::Top; + + ControlsInternal::Resizer* sizer = new ControlsInternal::Resizer( this ); + sizer->Dock( iSizeDirection ); + sizer->SetResizeDir( iSizeDirection ); + sizer->SetSize( 2, 2 ); + sizer->SetTarget( this ); +} + +void DockBase::Render( Skin::Base* /*skin*/ ) +{ + //Gwen::Render->SetDrawColor( Colors::Black ); + //Gwen::Render->DrawLinedRect( GetRenderBounds() ); +} + +DockBase** DockBase::GetChildDockPtr( int iPos ) +{ + if ( iPos == Pos::Left ) return &m_Left; + if ( iPos == Pos::Right ) return &m_Right; + if ( iPos == Pos::Top ) return &m_Top; + if ( iPos == Pos::Bottom ) return &m_Bottom; + + return NULL; +} + +DockBase* DockBase::GetChildDock( int iPos ) +{ + DockBase** pDock = GetChildDockPtr( iPos ); + + if ( !(*pDock) ) + { + (*pDock) = new DockBase( this ); + (*pDock)->SetupChildDock( iPos ); + } + else + { + (*pDock)->SetHidden( false ); + } + + return *pDock; +} + +int DockBase::GetDroppedTabDirection( int x, int y ) +{ + int w = Width(); + int h = Height(); + + float top = (float)y / (float) h; + float left = (float)x / (float) w; + float right = (float)(w - x) /(float) w; + float bottom = (float)(h - y) / (float) h; + + float minimum = GwenUtil_Min( GwenUtil_Min( GwenUtil_Min( top, left ), right ), bottom ); + m_bDropFar = ( minimum < 0.2f ); + if ( minimum > 0.3 ) return Pos::Fill; + + if ( top == minimum && (!m_Top || m_Top->Hidden()) ) return Pos::Top; + if ( left == minimum && (!m_Left || m_Left->Hidden()) ) return Pos::Left; + if ( right == minimum && (!m_Right || m_Right->Hidden()) ) return Pos::Right; + if ( bottom == minimum && (!m_Bottom || m_Bottom->Hidden()) ) return Pos::Bottom; + + return Pos::Fill; +} + +bool DockBase::DragAndDrop_CanAcceptPackage( Gwen::DragAndDrop::Package* pPackage ) +{ + // A TAB button dropped + if ( pPackage->name == "TabButtonMove" ) + return true; + + // a TAB window dropped + if ( pPackage->name == "TabWindowMove" ) + return true; + + return false; +} + +bool DockBase::DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* pPackage, int x, int y ) +{ + Gwen::Point pPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + int dir = GetDroppedTabDirection( pPos.x, pPos.y ); + + DockedTabControl* pAddTo = m_DockedTabControl; + if ( dir == Pos::Fill && pAddTo == NULL ) return false; + + if ( dir != Pos::Fill ) + { + DockBase* pDock = GetChildDock( dir ); + pAddTo = pDock->m_DockedTabControl; + + if ( !m_bDropFar ) pDock->BringToFront(); + else pDock->SendToBack(); + } + + if ( pPackage->name == "TabButtonMove" ) + { + TabButton* pTabButton = gwen_cast( DragAndDrop::SourceControl ); + if ( !pTabButton ) return false; + + pAddTo->AddPage( pTabButton ); + } + + if ( pPackage->name == "TabWindowMove" ) + { + DockedTabControl* pTabControl = gwen_cast( DragAndDrop::SourceControl ); + if ( !pTabControl ) return false; + if ( pTabControl == pAddTo ) return false; + + pTabControl->MoveTabsTo( pAddTo ); + } + + Invalidate(); + + return true; +} + +bool DockBase::IsEmpty() +{ + if ( m_DockedTabControl && m_DockedTabControl->TabCount() > 0 ) return false; + + if ( m_Left && !m_Left->IsEmpty() ) return false; + if ( m_Right && !m_Right->IsEmpty() ) return false; + if ( m_Top && !m_Top->IsEmpty() ) return false; + if ( m_Bottom && !m_Bottom->IsEmpty() ) return false; + + return true; +} + +void DockBase::OnTabRemoved( Gwen::Controls::Base* /*pControl*/ ) +{ + DoRedundancyCheck(); + DoConsolidateCheck(); +} + +void DockBase::DoRedundancyCheck() +{ + if ( !IsEmpty() ) return; + + DockBase* pDockParent = gwen_cast( GetParent() ); + if ( !pDockParent ) return; + + pDockParent->OnRedundantChildDock( this ); +} + +void DockBase::DoConsolidateCheck() +{ + if ( IsEmpty() ) return; + if ( !m_DockedTabControl ) return; + if ( m_DockedTabControl->TabCount() > 0 ) return; + + if ( m_Bottom && !m_Bottom->IsEmpty() ) + { + m_Bottom->m_DockedTabControl->MoveTabsTo( m_DockedTabControl ); + return; + } + + if ( m_Top && !m_Top->IsEmpty() ) + { + m_Top->m_DockedTabControl->MoveTabsTo( m_DockedTabControl ); + return; + } + + if ( m_Left && !m_Left->IsEmpty() ) + { + m_Left->m_DockedTabControl->MoveTabsTo( m_DockedTabControl ); + return; + } + + if ( m_Right && !m_Right->IsEmpty() ) + { + m_Right->m_DockedTabControl->MoveTabsTo( m_DockedTabControl ); + return; + } +} + +void DockBase::OnRedundantChildDock( DockBase* pDockBase ) +{ + pDockBase->SetHidden( true ); + DoRedundancyCheck(); + DoConsolidateCheck(); +} + +void DockBase::DragAndDrop_HoverEnter( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ) +{ + m_bDrawHover = true; +} + +void DockBase::DragAndDrop_HoverLeave( Gwen::DragAndDrop::Package* /*pPackage*/ ) +{ + m_bDrawHover = false; +} + +void DockBase::DragAndDrop_Hover( Gwen::DragAndDrop::Package* /*pPackage*/, int x, int y ) +{ + Gwen::Point pPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + int dir = GetDroppedTabDirection( pPos.x, pPos.y ); + + if ( dir == Pos::Fill ) + { + if ( !m_DockedTabControl ) + { + m_HoverRect = Gwen::Rect( 0, 0, 0, 0 ); + return; + } + + m_HoverRect = GetInnerBounds(); + return; + } + + m_HoverRect = GetRenderBounds(); + + int HelpBarWidth = 0; + + if ( dir == Pos::Left ) + { + HelpBarWidth = m_HoverRect.w * 0.25f; + m_HoverRect.w = HelpBarWidth; + } + + if ( dir == Pos::Right ) + { + HelpBarWidth = m_HoverRect.w * 0.25f; + m_HoverRect.x = m_HoverRect.w - HelpBarWidth; + m_HoverRect.w = HelpBarWidth; + } + + if ( dir == Pos::Top ) + { + HelpBarWidth = m_HoverRect.h * 0.25f; + m_HoverRect.h = HelpBarWidth; + } + + if ( dir == Pos::Bottom ) + { + HelpBarWidth = m_HoverRect.h * 0.25f; + m_HoverRect.y = m_HoverRect.h - HelpBarWidth; + m_HoverRect.h = HelpBarWidth; + } + + if ( (dir == Pos::Top || dir == Pos::Bottom ) && !m_bDropFar ) + { + if ( m_Left && m_Left->Visible() ) + { + m_HoverRect.x += m_Left->Width(); + m_HoverRect.w -= m_Left->Width(); + } + + if ( m_Right && m_Right->Visible() ) + { + m_HoverRect.w -= m_Right->Width(); + } + } + + if ( (dir == Pos::Left || dir == Pos::Right ) && !m_bDropFar ) + { + if ( m_Top && m_Top->Visible() ) + { + m_HoverRect.y += m_Top->Height(); + m_HoverRect.h -= m_Top->Height(); + } + + if ( m_Bottom && m_Bottom->Visible() ) + { + m_HoverRect.h -= m_Bottom->Height(); + } + } +} + +void DockBase::RenderOver( Skin::Base* skin ) +{ + if ( !m_bDrawHover ) return; + + Gwen::Renderer::Base* render = skin->GetRender(); + + render->SetDrawColor( Gwen::Color( 255, 100, 255, 20 ) ); + render->DrawFilledRect( GetRenderBounds() ); + + if ( m_HoverRect.w == 0 ) return; + + render->SetDrawColor( Gwen::Color( 255, 100, 255, 100 ) ); + render->DrawFilledRect( m_HoverRect ); + + render->SetDrawColor( Gwen::Color( 255, 100, 255, 200 ) ); + render->DrawLinedRect( m_HoverRect ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_dockbase.h b/lib/gwen/controls/gwen_dockbase.h new file mode 100644 index 0000000..c61ece9 --- /dev/null +++ b/lib/gwen/controls/gwen_dockbase.h @@ -0,0 +1,77 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_DOCKBASE_H +#define GWEN_CONTROLS_DOCKBASE_H + +#include "gwen_base.h" +#include "gwen_button.h" + +namespace Gwen +{ + namespace Controls + { + class DockedTabControl; + class TabControl; + + class GWEN_EXPORT DockBase : public Base + { + public: + + GWEN_CONTROL( DockBase, Base ); + + virtual void Render( Skin::Base* skin ); + virtual void RenderOver( Skin::Base* skin ); + virtual bool IsEmpty(); + + virtual TabControl* GetTabControl(); + + virtual DockBase* GetRight(){ return GetChildDock( Pos::Right ); } + virtual DockBase* GetLeft(){ return GetChildDock( Pos::Left ); } + virtual DockBase* GetTop(){ return GetChildDock( Pos::Top ); } + virtual DockBase* GetBottom(){ return GetChildDock( Pos::Bottom ); } + + // No action on space (default button action is to press) + virtual bool OnKeySpace( bool /*bDown*/ ){ return false; } + + private: + + // Drag n Drop + virtual bool DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual bool DragAndDrop_CanAcceptPackage( Gwen::DragAndDrop::Package* pPackage ); + virtual void DragAndDrop_HoverEnter( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual void DragAndDrop_HoverLeave( Gwen::DragAndDrop::Package* pPackage ); + virtual void DragAndDrop_Hover( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + + virtual void SetupChildDock( int iPos ); + + virtual void DoRedundancyCheck(); + virtual void DoConsolidateCheck(); + virtual void OnRedundantChildDock( DockBase* pDockBase ); + + virtual int GetDroppedTabDirection( int x, int y ); + virtual void OnTabRemoved( Gwen::Controls::Base* pControl ); + + DockBase* GetChildDock( int iPos ); + DockBase** GetChildDockPtr( int iPos ); + + DockBase* m_Left; + DockBase* m_Right; + DockBase* m_Top; + DockBase* m_Bottom; + + // Only CHILD dockpanels have a tabcontrol. + DockedTabControl* m_DockedTabControl; + + bool m_bDrawHover; + bool m_bDropFar; + Gwen::Rect m_HoverRect; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_dockedtabcontrol.cpp b/lib/gwen/controls/gwen_dockedtabcontrol.cpp new file mode 100644 index 0000000..a37a8c1 --- /dev/null +++ b/lib/gwen/controls/gwen_dockedtabcontrol.cpp @@ -0,0 +1,94 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_dockedtabcontrol.h" +#include "gwen_highlight.h" +#include "../gwen_draganddrop.h" +#include "gwen_windowcontrol.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( DockedTabControl ) +{ + m_WindowControl = NULL; + + Dock( Pos::Fill ); + + m_pTitleBar = new TabTitleBar( this ); + m_pTitleBar->Dock( Pos::Top ); + m_pTitleBar->SetHidden( true ); + + SetAllowReorder( true ); + +} + +void DockedTabControl::Layout( Skin::Base* skin ) +{ + GetTabStrip()->SetHidden( TabCount() <= 1 ); + UpdateTitleBar(); + BaseClass::Layout( skin ); +} + +void DockedTabControl::UpdateTitleBar() +{ + if ( !GetCurrentButton() ) return; + + m_pTitleBar->UpdateFromTab( GetCurrentButton() ); +} + +void DockedTabControl::DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y ) +{ + BaseClass::DragAndDrop_StartDragging( pPackage, x, y ); + + SetHidden( true ); + // This hiding our parent thing is kind of lousy. + GetParent()->SetHidden( true ); +} + +void DockedTabControl::DragAndDrop_EndDragging( bool bSuccess, int /*x*/, int /*y*/ ) +{ + SetHidden( false ); + + if ( !bSuccess ) + { + GetParent()->SetHidden( false ); + } + +/* + if ( !bSuccess ) + { + // Create our window control + if ( !m_WindowControl ) + { + m_WindowControl = new WindowControl( GetCanvas() ); + m_WindowControl->SetBounds( x, y, Width(), Height() ); + } + + m_WindowControl->SetPosition( x, y ); + SetParent( m_WindowControl ); + SetPosition( 0, 0 ); + Dock( Pos::Fill ); + } + */ +} + +void DockedTabControl::MoveTabsTo( DockedTabControl* pTarget ) +{ + Base::List Children = GetTabStrip()->Children; + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + TabButton* pButton = gwen_cast(*iter); + if ( !pButton ) continue; + + pTarget->AddPage( pButton ); + } + + Invalidate(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_dockedtabcontrol.h b/lib/gwen/controls/gwen_dockedtabcontrol.h new file mode 100644 index 0000000..cb627dd --- /dev/null +++ b/lib/gwen/controls/gwen_dockedtabcontrol.h @@ -0,0 +1,42 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_DOCKEDTABCONTROL_H +#define GWEN_CONTROLS_DOCKEDTABCONTROL_H + +#include "gwen_base.h" +#include "gwen_tabcontrol.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT DockedTabControl : public TabControl + { + public: + + GWEN_CONTROL( DockedTabControl, TabControl ); + + void SetShowTitlebar( bool bShow ){ m_pTitleBar->SetHidden( !bShow ); } + + void Layout( Skin::Base* skin ); + void UpdateTitleBar(); + + virtual void DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual void DragAndDrop_EndDragging( bool bSuccess, int x, int y ); + + void MoveTabsTo( DockedTabControl* pTarget ); + + private: + + TabTitleBar* m_pTitleBar; + Base* m_WindowControl; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_dragger.cpp b/lib/gwen/controls/gwen_dragger.cpp new file mode 100644 index 0000000..d7ce5ae --- /dev/null +++ b/lib/gwen/controls/gwen_dragger.cpp @@ -0,0 +1,70 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_dragger.h" + +using namespace Gwen; +using namespace Gwen::ControlsInternal; + + + +GWEN_CONTROL_CONSTRUCTOR( Dragger ) +{ + m_pTarget = NULL; + SetMouseInputEnabled( true ); + m_bDepressed = false; + m_bDoMove = true; +} + +void Dragger::OnMouseClickLeft( int x, int y, bool bDown ) +{ + if ( bDown ) + { + m_bDepressed = true; + + if ( m_pTarget) + m_HoldPos = m_pTarget->CanvasPosToLocal( Gwen::Point( x, y ) ); + + Gwen::MouseFocus = this; + onDragStart.Call( this ); + } + else + { + m_bDepressed = false; + Gwen::MouseFocus = NULL; + } +} + +void Dragger::OnMouseMoved( int x, int y, int deltaX, int deltaY ) +{ + if ( !m_bDepressed ) return; + + if ( m_bDoMove && m_pTarget ) + { + Gwen::Point p = Gwen::Point( x - m_HoldPos.x, y - m_HoldPos.y ); + + // Translate to parent + if ( m_pTarget->GetParent() ) + p = m_pTarget->GetParent()->CanvasPosToLocal( p ); + + m_pTarget->MoveTo( p.x, p.y ); + } + + Gwen::Event::Information info; + info.Point = Gwen::Point( deltaX, deltaY ); + onDragged.Call( this, info ); +} + +void Dragger::Render( Skin::Base* skin ) +{ + //skin->DrawButton(this,false,false, false); +} + +void Dragger::OnMouseDoubleClickLeft( int x, int y ) +{ + onDoubleClickLeft.Call( this ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_dragger.h b/lib/gwen/controls/gwen_dragger.h new file mode 100644 index 0000000..61059f3 --- /dev/null +++ b/lib/gwen/controls/gwen_dragger.h @@ -0,0 +1,52 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_DRAGGER_H +#define GWEN_CONTROLS_DRAGGER_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT Dragger : public Controls::Base + { + public: + + GWEN_CONTROL( Dragger, Controls::Base ); + + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + virtual void Render( Skin::Base* skin ); + + virtual void SetTarget( Controls::Base* pBase ){ m_pTarget = pBase; } + virtual bool IsDepressed(){ return m_bDepressed; } + + virtual void SetDoMove( bool b ){ m_bDoMove = b; } + + virtual void OnMouseDoubleClickLeft( int x, int y ); + + Gwen::Event::Caller onDragged; + Gwen::Event::Caller onDragStart; + + Gwen::Event::Caller onDoubleClickLeft; + + protected: + + bool m_bDepressed; + Gwen::Point m_HoldPos; + Controls::Base* m_pTarget; + bool m_bDoMove; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_fieldlabel.h b/lib/gwen/controls/gwen_fieldlabel.h new file mode 100644 index 0000000..08c8177 --- /dev/null +++ b/lib/gwen/controls/gwen_fieldlabel.h @@ -0,0 +1,64 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_FIELDLABEL_H +#define GWEN_CONTROLS_FIELDLABEL_H + +#include "../gwen_baserender.h" +#include "gwen_label.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT FieldLabel : public Controls::Label + { + public: + + static inline FieldLabel* Setup( Controls::Base* pControl, const Gwen::TextObject& text ) + { + FieldLabel* plbl = new FieldLabel( pControl->GetParent() ); + plbl->SetText( text ); + plbl->SetSize( pControl->Width(), pControl->Height() ); + plbl->Dock( pControl->GetDock() ); + + plbl->SetField( pControl ); + return plbl; + } + + public: + + GWEN_CONTROL_INLINE( FieldLabel, Controls::Label ) + { + m_pField = NULL; + SetMargin( Margin( 0, 1, 0, 1 ) ); + SetAlignment( Pos::CenterV | Pos::Left ); + } + + void SetField( Controls::Base* pField ) + { + pField->SetParent( this ); + pField->Dock( Pos::Right ); + m_pField = pField; + } + + void Layout( Gwen::Skin::Base* pskin ) + { + m_pField->SetWidth( Width() - 70 ); + + BaseClass::Layout( pskin ); + } + + protected: + + Controls::Base* m_pField; + + }; + } +} + +#endif diff --git a/lib/gwen/controls/gwen_groupbox.cpp b/lib/gwen/controls/gwen_groupbox.cpp new file mode 100644 index 0000000..78d01c5 --- /dev/null +++ b/lib/gwen/controls/gwen_groupbox.cpp @@ -0,0 +1,44 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_groupbox.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( GroupBox ) +{ + // Set to true, because it's likely that our + // children will want mouse input, and they + // can't get it without us.. + SetMouseInputEnabled( true ); + + SetTextPadding( Padding( 10, 0, 0, 0 ) ); + + SetAlignment( Pos::Top | Pos::Left ); + Invalidate(); + + m_InnerPanel = new Base( this ); + m_InnerPanel->Dock( Pos::Fill ); + + m_InnerMargin = 6; + +} + +void GroupBox::Layout( Skin::Base* skin ) +{ + m_InnerPanel->SetMargin( Margin( m_InnerMargin, TextHeight() - 3 + m_InnerMargin, m_InnerMargin, m_InnerMargin ) ); + + BaseClass::Layout( skin ); +} + + +void GroupBox::Render( Skin::Base* skin ) +{ + skin->DrawGroupBox( this, TextX(), TextHeight(), TextWidth() ); +} diff --git a/lib/gwen/controls/gwen_groupbox.h b/lib/gwen/controls/gwen_groupbox.h new file mode 100644 index 0000000..41cd5bb --- /dev/null +++ b/lib/gwen/controls/gwen_groupbox.h @@ -0,0 +1,40 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_GROUPBOX_H +#define GWEN_CONTROLS_GROUPBOX_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT GroupBox : public Label + { + public: + + GWEN_CONTROL( GroupBox, Label ); + + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + + virtual void SetInnerMargin( int i ){ m_InnerMargin = i; } + + protected: + + int m_InnerMargin; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_highlight.h b/lib/gwen/controls/gwen_highlight.h new file mode 100644 index 0000000..2d2a79b --- /dev/null +++ b/lib/gwen/controls/gwen_highlight.h @@ -0,0 +1,36 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_HIGHLIGHT_H +#define GWEN_CONTROLS_HIGHLIGHT_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT Highlight : public Controls::Base + { + public: + + GWEN_CONTROL_INLINE( Highlight, Controls::Base ) + { + + } + + void Render( Skin::Base* skin ) + { + skin->DrawHighlight( this ); + } + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_horizontalscrollbar.cpp b/lib/gwen/controls/gwen_horizontalscrollbar.cpp new file mode 100644 index 0000000..b905bf0 --- /dev/null +++ b/lib/gwen/controls/gwen_horizontalscrollbar.cpp @@ -0,0 +1,136 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollbar.h" +#include "gwen_horizontalscrollbar.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( HorizontalScrollBar ) +{ + m_Bar->SetHorizontal(); + + m_ScrollButton[SCROLL_BUTTON_LEFT]->SetDirectionLeft(); + m_ScrollButton[SCROLL_BUTTON_LEFT]->onPress.Add( this, &HorizontalScrollBar::NudgeLeft ); + + m_ScrollButton[SCROLL_BUTTON_RIGHT]->SetDirectionRight(); + m_ScrollButton[SCROLL_BUTTON_RIGHT]->onPress.Add( this, &HorizontalScrollBar::NudgeRight ); + + m_Bar->onDragged.Add( this, &HorizontalScrollBar::OnBarMoved ); +} + +void HorizontalScrollBar::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + m_ScrollButton[SCROLL_BUTTON_LEFT]->SetWidth( Height() ); + m_ScrollButton[SCROLL_BUTTON_LEFT]->Dock(Pos::Left); + + m_ScrollButton[SCROLL_BUTTON_RIGHT]->SetWidth( Height() ); + m_ScrollButton[SCROLL_BUTTON_RIGHT]->Dock(Pos::Right); + + m_Bar->SetHeight( GetButtonSize() ); + m_Bar->SetPadding( Padding( GetButtonSize(), 0, GetButtonSize(), 0 ) ); + + float barWidth = (m_fViewableContentSize / m_fContentSize) * (Width() - GetButtonSize()); + + if ( barWidth < GetButtonSize() * 0.5 ) + barWidth = GetButtonSize() * 0.5; + + m_Bar->SetWidth( barWidth ); + m_Bar->SetHidden( Width() - (GetButtonSize() * 2) <= barWidth ); + + //Based on our last scroll amount, produce a position for the bar + if ( !m_Bar->IsDepressed() ) + { + SetScrolledAmount( GetScrolledAmount(), true ); + } +} + +void HorizontalScrollBar::NudgeLeft( Base* /*control*/ ) +{ + if ( !IsDisabled() ) + SetScrolledAmount( GetScrolledAmount() - GetNudgeAmount(), true); +} + +void HorizontalScrollBar::NudgeRight( Base* /*control*/ ) +{ + if ( !IsDisabled() ) + SetScrolledAmount( GetScrolledAmount() + GetNudgeAmount(), true); +} + +void HorizontalScrollBar::ScrollToLeft() +{ + SetScrolledAmount( 0, true); +} +void HorizontalScrollBar::ScrollToRight() +{ + SetScrolledAmount( 1, true); +} + +float HorizontalScrollBar::GetNudgeAmount() +{ + if ( m_bDepressed ) + return m_fViewableContentSize / m_fContentSize; + else + return BaseClass::GetNudgeAmount(); +} + + + +void HorizontalScrollBar::OnMouseClickLeft( int x, int y, bool bDown ) +{ + if ( bDown ) + { + m_bDepressed = true; + Gwen::MouseFocus = this; + } + else + { + Gwen::Point clickPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + if ( clickPos.x < m_Bar->X() ) + NudgeLeft( this ); + else if ( clickPos.x > m_Bar->X() + m_Bar->Width() ) + NudgeRight( this ); + + m_bDepressed = false; + Gwen::MouseFocus = NULL; + } +} + +float HorizontalScrollBar::CalculateScrolledAmount() +{ + return (float)(m_Bar->X() - GetButtonSize()) / (float)(Width() - m_Bar->Width() - (GetButtonSize() * 2 )); +} + +bool HorizontalScrollBar::SetScrolledAmount( float amount, bool forceUpdate ) +{ + amount = Gwen::Clamp( amount, 0, 1 ); + + if ( !BaseClass::SetScrolledAmount( amount, forceUpdate ) ) + return false; + + if ( forceUpdate ) + { + int newX = GetButtonSize() + (amount * ((Width() - m_Bar->Width()) - (GetButtonSize()*2))); + m_Bar->MoveTo( newX, m_Bar->Y() ); + } + + return true; +} + +void HorizontalScrollBar::OnBarMoved( Controls::Base* control ) +{ + if ( m_Bar->IsDepressed() ) + { + SetScrolledAmount( CalculateScrolledAmount(), false ); + BaseClass::OnBarMoved(control); + } + else + InvalidateParent(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_horizontalscrollbar.h b/lib/gwen/controls/gwen_horizontalscrollbar.h new file mode 100644 index 0000000..f4b8236 --- /dev/null +++ b/lib/gwen/controls/gwen_horizontalscrollbar.h @@ -0,0 +1,51 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_HORIZONTALSCROLLBAR_H +#define GWEN_CONTROLS_HORIZONTALSCROLLBAR_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_dragger.h" +#include "gwen_scrollbar.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT HorizontalScrollBar : public BaseScrollBar + { + public: + + GWEN_CONTROL( HorizontalScrollBar, BaseScrollBar ); + + virtual void Layout( Skin::Base* skin ); + + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + virtual void OnBarMoved( Controls::Base* control ); + + virtual int GetBarSize() { return m_Bar->Width(); } + virtual int GetBarPos() { return m_Bar->X() - Height(); } + virtual void SetBarSize( int size ) { m_Bar->SetWidth( size ); } + virtual int GetButtonSize() { return Height(); } + + virtual void ScrollToLeft(); + virtual void ScrollToRight(); + virtual void NudgeLeft( Base* control ); + virtual void NudgeRight( Base* control ); + virtual float GetNudgeAmount(); + + virtual float CalculateScrolledAmount(); + virtual bool SetScrolledAmount(float amount, bool forceUpdate); + + virtual bool IsHorizontal(){ return true; } + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_horizontalslider.cpp b/lib/gwen/controls/gwen_horizontalslider.cpp new file mode 100644 index 0000000..7b9c958 --- /dev/null +++ b/lib/gwen/controls/gwen_horizontalslider.cpp @@ -0,0 +1,46 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_slider.h" +#include "gwen_horizontalslider.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( HorizontalSlider ) +{ + m_SliderBar->SetHorizontal( true ); +} + +float HorizontalSlider::CalculateValue() +{ + return (float)m_SliderBar->X() / (float)( Width() - m_SliderBar->Width() ); +} + +void HorizontalSlider::UpdateBarFromValue() +{ + m_SliderBar->MoveTo( ( Width() - m_SliderBar->Width() ) * ( m_fValue ), m_SliderBar->Y() ); +} + +void HorizontalSlider::OnMouseClickLeft( int x, int y, bool bDown ) +{ + m_SliderBar->MoveTo( CanvasPosToLocal( Gwen::Point( x, y ) ).x - m_SliderBar->Width() * 0.5, m_SliderBar->Y() ); + m_SliderBar->OnMouseClickLeft( x, y, bDown ); + OnMoved( m_SliderBar ); +} + +void HorizontalSlider::Layout(Skin::Base* /*skin*/) +{ + m_SliderBar->SetSize( 15, Height() ); +} + +void HorizontalSlider::Render( Skin::Base* skin ) +{ + skin->DrawSlider( this, true, m_bClampToNotches ? m_iNumNotches : 0, m_SliderBar->Width() ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_horizontalslider.h b/lib/gwen/controls/gwen_horizontalslider.h new file mode 100644 index 0000000..674be36 --- /dev/null +++ b/lib/gwen/controls/gwen_horizontalslider.h @@ -0,0 +1,35 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_HORIZONTALSLIDER_H +#define GWEN_CONTROLS_HORIZONTALSLIDER_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_dragger.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_slider.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT HorizontalSlider : public Slider + { + GWEN_CONTROL( HorizontalSlider, Slider ); + + virtual void Layout( Skin::Base* skin ); + virtual void Render( Skin::Base* skin ); + + virtual float CalculateValue(); + virtual void UpdateBarFromValue(); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_hsvcolorpicker.cpp b/lib/gwen/controls/gwen_hsvcolorpicker.cpp new file mode 100644 index 0000000..b347c6d --- /dev/null +++ b/lib/gwen/controls/gwen_hsvcolorpicker.cpp @@ -0,0 +1,174 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_hsvcolorpicker.h" +#include "gwen_colorcontrols.h" +#include "gwen_colorpicker.h" +#include "gwen_textbox.h" +#include "gwen_label.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( HSVColorPicker ) +{ + SetMouseInputEnabled( true ); + SetSize( 256, 64 ); + SetCacheToTexture(); + + m_LerpBox = new Gwen::Controls::ColorLerpBox( this ); + m_LerpBox->onSelectionChanged.Add( this, &HSVColorPicker::ColorBoxChanged ); + m_LerpBox->Dock( Pos::Left ); + + m_ColorSlider = new Gwen::Controls::ColorSlider( this ); + m_ColorSlider->SetPos( m_LerpBox->Width() + 15, 5 ); + m_ColorSlider->onSelectionChanged.Add( this, &HSVColorPicker::ColorSliderChanged ); + m_ColorSlider->Dock( Pos::Left ); + + m_After = new Gwen::ControlsInternal::ColorDisplay( this ); + m_After->SetSize( 48, 24 ); + m_After->SetPos( m_ColorSlider->X() + m_ColorSlider->Width() + 15, 5 ); + + m_Before = new Gwen::ControlsInternal::ColorDisplay( this ); + m_Before->SetSize( 48, 24 ); + m_Before->SetPos( m_After->X(), 28 ); + + int x = m_Before->X(); + int y = m_Before->Y() + 30; + + + { + Label* label = new Label( this ); + label->SetText("R:"); + label->SizeToContents(); + label->SetPos( x, y ); + + TextBoxNumeric* numeric = new TextBoxNumeric( this ); + numeric->SetName( "RedBox" ); + numeric->SetPos( x + 15, y -1 ); + numeric->SetSize( 26, 16 ); + numeric->SetSelectAllOnFocus( true ); + numeric->onTextChanged.Add( this, &HSVColorPicker::NumericTyped ); + + } + + y+= 20; + + { + Label* label = new Label( this ); + label->SetText("G:"); + label->SizeToContents(); + label->SetPos( x, y ); + + + TextBoxNumeric* numeric = new TextBoxNumeric( this ); + numeric->SetName( "GreenBox" ); + numeric->SetPos( x + 15, y -1 ); + numeric->SetSize( 26, 16 ); + numeric->SetSelectAllOnFocus( true ); + numeric->onTextChanged.Add( this, &HSVColorPicker::NumericTyped ); + } + + y+= 20; + + { + Label* label = new Label( this ); + label->SetText("B:"); + label->SizeToContents(); + label->SetPos( x, y ); + + + TextBoxNumeric* numeric = new TextBoxNumeric( this ); + numeric->SetName( "BlueBox" ); + numeric->SetPos( x + 15, y -1 ); + numeric->SetSize( 26, 16 ); + numeric->SetSelectAllOnFocus( true ); + numeric->onTextChanged.Add( this, &HSVColorPicker::NumericTyped ); + } +} + +void HSVColorPicker::NumericTyped( Gwen::Controls::Base* control ) +{ + TextBoxNumeric* box = gwen_cast(control); + if ( !box ) return; + + if ( box->GetText() == "" ) return; + + int textValue = atoi( box->GetText().c_str() ); + if ( textValue < 0 ) textValue = 0; + if ( textValue > 255 ) textValue = 255; + + Gwen::Color newColor = GetColor(); + + if ( box->GetName().find( "Red" ) != Gwen::String::npos ) + { + newColor.r = textValue; + } + else if ( box->GetName().find( "Green" ) != Gwen::String::npos ) + { + newColor.g = textValue; + } + else if ( box->GetName().find( "Blue" ) != Gwen::String::npos ) + { + newColor.b = textValue; + } + else if ( box->GetName().find( "Alpha" ) != Gwen::String::npos ) + { + newColor.a = textValue; + } + + SetColor( newColor ); +} + +void HSVColorPicker::UpdateControls(Gwen::Color color) +{ + // What in the FUCK + + TextBoxNumeric* redBox = gwen_cast( FindChildByName( "RedBox", false ) ); + if ( redBox ) redBox->SetText( Gwen::Utility::ToString( (int)color.r), false ); + + TextBoxNumeric* greenBox = gwen_cast( FindChildByName( "GreenBox", false ) ); + if ( greenBox ) greenBox->SetText( Gwen::Utility::ToString( (int)color.g ), false ); + + TextBoxNumeric* blueBox = gwen_cast( FindChildByName( "BlueBox", false ) ); + if ( blueBox ) blueBox->SetText( Gwen::Utility::ToString( (int)color.b ), false ); + + m_After->SetColor( color ); +} +void HSVColorPicker::SetColor( Gwen::Color color, bool onlyHue, bool reset ) +{ + + UpdateControls( color ); + + + if ( reset ) + m_Before->SetColor( color ); + + m_ColorSlider->SetColor( color ); + m_LerpBox->SetColor( color, onlyHue ); + m_After->SetColor( color ); +} + +Gwen::Color HSVColorPicker::GetColor() +{ + return m_LerpBox->GetSelectedColor(); +} + +void HSVColorPicker::ColorBoxChanged( Gwen::Controls::Base* /*pControl*/ ) +{ + onColorChanged.Call( this ); + UpdateControls( GetColor() ); + Invalidate(); +} +void HSVColorPicker::ColorSliderChanged( Gwen::Controls::Base* /*pControl*/ ) +{ + if ( m_LerpBox ) + m_LerpBox->SetColor( m_ColorSlider->GetSelectedColor(), true ); + Invalidate(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_hsvcolorpicker.h b/lib/gwen/controls/gwen_hsvcolorpicker.h new file mode 100644 index 0000000..7b92a52 --- /dev/null +++ b/lib/gwen/controls/gwen_hsvcolorpicker.h @@ -0,0 +1,47 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_HSVCOLORPICKER_H +#define GWEN_CONTROLS_HSVCOLORPICKER_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_colorcontrols.h" +#include "gwen_colorpicker.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT HSVColorPicker : public Controls::Base + { + public: + GWEN_CONTROL( HSVColorPicker, Controls::Base ); + + Gwen::Color GetColor(); + Gwen::Color GetDefaultColor() { return m_Before->GetColor(); } + void SetColor( Gwen::Color color, bool onlyHue = false, bool reset = false ); + + void ColorBoxChanged( Gwen::Controls::Base* pControl ); + void ColorSliderChanged( Gwen::Controls::Base* pControl ); + void NumericTyped( Gwen::Controls::Base* control ); + + void UpdateControls( Gwen::Color newColor ); + + Event::Caller onColorChanged; + + protected: + ColorLerpBox* m_LerpBox; + ColorSlider* m_ColorSlider; + ControlsInternal::ColorDisplay* m_Before; + ControlsInternal::ColorDisplay* m_After; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_imagepanel.cpp b/lib/gwen/controls/gwen_imagepanel.cpp new file mode 100644 index 0000000..87b802d --- /dev/null +++ b/lib/gwen/controls/gwen_imagepanel.cpp @@ -0,0 +1,9 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_imagepanel.h" + diff --git a/lib/gwen/controls/gwen_imagepanel.h b/lib/gwen/controls/gwen_imagepanel.h new file mode 100644 index 0000000..5fe9df5 --- /dev/null +++ b/lib/gwen/controls/gwen_imagepanel.h @@ -0,0 +1,115 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_IMAGEPANEL_H +#define GWEN_CONTROLS_IMAGEPANEL_H + +#include "../gwen.h" +#include "gwen_base.h" +#include "../gwen_baserender.h" +#include "../gwen_texture.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT ImagePanel : public Controls::Base + { + public: + + GWEN_CONTROL_INLINE( ImagePanel, Controls::Base ) + { + SetUV( 0, 0, 1, 1 ); + SetMouseInputEnabled( false ); + m_DrawColor = Colors::White; + + SetStretch( true ); + } + + virtual ~ImagePanel() + { + m_Texture.Release( GetSkin()->GetRender() ); + } + + virtual void SetUV( float u1, float v1, float u2, float v2 ) + { + m_uv[0] = u1; + m_uv[1] = v1; + m_uv[2] = u2; + m_uv[3] = v2; + } + + virtual void SetImage( const TextObject& imageName ) + { + m_Texture.Load( imageName, GetSkin()->GetRender() ); + } + + virtual void SetImage( const Texture& texture ) + { + m_Texture = texture; + } + + virtual TextObject& GetImage() + { + return m_Texture.name; + } + + virtual int TextureWidth() + { + return m_Texture.width; + } + + virtual int TextureHeight() + { + return m_Texture.height; + } + + virtual const TextObject& GetImageName() + { + return m_Texture.name; + } + + virtual void Render( Skin::Base* skin ) + { + skin->GetRender()->SetDrawColor( m_DrawColor ); + + if ( m_bStretch ) + skin->GetRender()->DrawTexturedRect( &m_Texture, GetRenderBounds(), m_uv[0], m_uv[1], m_uv[2], m_uv[3] ); + else + skin->GetRender()->DrawTexturedRect( &m_Texture, Gwen::Rect( 0, 0, m_Texture.width, m_Texture.height ), m_uv[0], m_uv[1], m_uv[2], m_uv[3] ); + } + + virtual void SizeToContents() + { + SetSize( m_Texture.width, m_Texture.height ); + } + + virtual void SetDrawColor( Gwen::Color color ) + { + m_DrawColor = color; + } + + virtual bool FailedToLoad() + { + return m_Texture.FailedToLoad(); + } + + virtual bool GetStretch(){ return m_bStretch; } + virtual void SetStretch( bool b ){ m_bStretch = b; } + + protected: + + Texture m_Texture; + float m_uv[4]; + Gwen::Color m_DrawColor; + + bool m_bStretch; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_label.cpp b/lib/gwen/controls/gwen_label.cpp new file mode 100644 index 0000000..3636c88 --- /dev/null +++ b/lib/gwen/controls/gwen_label.cpp @@ -0,0 +1,115 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_label.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( Label ) +{ + m_CreatedFont = NULL; + + m_Text = new ControlsInternal::Text( this ); + m_Text->SetFont( GetSkin()->GetDefaultFont() ); + + SetMouseInputEnabled( false ); + SetBounds( 0, 0, 100, 10 ); + SetAlignment( Gwen::Pos::Left | Gwen::Pos::Top ); +} + +void Label::PreDelete( Gwen::Skin::Base* skin ) +{ + if ( m_CreatedFont ) + { + skin->ReleaseFont( m_CreatedFont ); + delete m_CreatedFont; + m_CreatedFont = NULL; + SetFont( NULL ); + } +} + +void Label::PostLayout( Skin::Base* /*skin*/ ) +{ + m_Text->Position( m_iAlign ); +} + +void Label::SetAlignment( int iAlign ) +{ + if ( m_iAlign == iAlign ) return; + + m_iAlign = iAlign; + Invalidate(); +} + +int Label::GetAlignment() +{ + return m_iAlign; +} + +void Label::SetText( const TextObject& str, bool bDoEvents ) +{ + if ( m_Text->GetText() == str.Get() ) return; + + m_Text->SetString( str ); + Redraw(); + + if ( bDoEvents ) + OnTextChanged(); +} + +void Label::SizeToContents() +{ + m_Text->SetPos( m_Padding.left, m_Padding.top ); + m_Text->RefreshSize(); + + SetSize( m_Text->Width() + m_Padding.left + m_Padding.right, m_Text->Height() + m_Padding.top + m_Padding.bottom ); +} + +Gwen::Rect Label::GetCharacterPosition( int iChar ) +{ + Gwen::Rect p = m_Text->GetCharacterPosition( iChar ); + p.x += m_Text->X(); + p.y += m_Text->Y(); + + return p; +} + +void Label::OnBoundsChanged( Gwen::Rect oldChildBounds ) +{ + BaseClass::OnBoundsChanged( oldChildBounds ); + + if ( m_Text->Wrap() ) + { + m_Text->RefreshSize(); + Invalidate(); + } +} + +void Label::SetFont( Gwen::String strFacename, int iSize, bool bBold ) +{ + if ( m_CreatedFont ) + { + GetSkin()->ReleaseFont( m_CreatedFont ); + delete m_CreatedFont; + m_CreatedFont = NULL; + SetFont( NULL ); + } + + m_CreatedFont = new Gwen::Font(); + Debug::AssertCheck( m_CreatedFont != NULL, "Couldn't Create Font!" ); + + m_CreatedFont->bold = bBold; + m_CreatedFont->facename = strFacename; + m_CreatedFont->size = iSize; + + SetFont( m_CreatedFont ); + + m_Text->RefreshSize(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_label.h b/lib/gwen/controls/gwen_label.h new file mode 100644 index 0000000..a1bb3bd --- /dev/null +++ b/lib/gwen/controls/gwen_label.h @@ -0,0 +1,84 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LABEL_H +#define GWEN_CONTROLS_LABEL_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_text.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT Label : public Controls::Base + { + public: + + GWEN_CONTROL( Label, Controls::Base ); + virtual void PreDelete( Gwen::Skin::Base* skin ); + + virtual void SetText( const TextObject& str, bool bDoEvents = true ); + + virtual const TextObject& GetText() const { return m_Text->GetText(); } + + virtual void Render( Skin::Base* /*skin*/ ){} + + virtual void PostLayout( Skin::Base* skin ); + + virtual void SizeToContents(); + + virtual void SetAlignment( int iAlign ); + virtual int GetAlignment(); + + + virtual void SetFont( Gwen::String strFacename, int iSize, bool bBold ); + + virtual void SetFont( Gwen::Font* pFont ){ m_Text->SetFont( pFont ); } + virtual Gwen::Font* GetFont(){ return m_Text->GetFont(); } + virtual void SetTextColor( const Gwen::Color& col ){ m_Text->SetTextColor( col ); } + virtual void SetTextColorOverride( const Gwen::Color& col ){ m_Text->SetTextColorOverride( col ); } + inline const Gwen::Color &TextColor() const { return m_Text->TextColor(); } + + virtual int TextWidth() { return m_Text->Width(); } + virtual int TextRight() { return m_Text->Right(); } + virtual int TextHeight() { return m_Text->Height(); } + virtual int TextX() { return m_Text->X(); } + virtual int TextY() { return m_Text->Y(); } + virtual int TextLength() { return m_Text->Length(); } + + Gwen::Rect GetCharacterPosition( int iChar ); + + virtual void SetTextPadding( const Padding& padding ){ m_Text->SetPadding( padding ); Invalidate(); InvalidateParent(); } + virtual const Padding& GetTextPadding(){ return m_Text->GetPadding(); } + + inline int Alignment() const { return m_iAlign; } + + virtual void MakeColorNormal(){ SetTextColor( GetSkin()->Colors.Label.Default ); } + virtual void MakeColorBright(){ SetTextColor( GetSkin()->Colors.Label.Bright ); } + virtual void MakeColorDark(){ SetTextColor( GetSkin()->Colors.Label.Dark ); } + virtual void MakeColorHighlight(){ SetTextColor( GetSkin()->Colors.Label.Highlight ); } + + virtual bool Wrap(){ return m_Text->Wrap(); } + virtual void SetWrap( bool b ){ m_Text->SetWrap( b ); } + + virtual void OnBoundsChanged( Gwen::Rect oldChildBounds ); + + protected: + + virtual void OnTextChanged(){}; + + Gwen::Font* m_CreatedFont; + ControlsInternal::Text* m_Text; + int m_iAlign; + + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_labelclickable.cpp b/lib/gwen/controls/gwen_labelclickable.cpp new file mode 100644 index 0000000..39ffe82 --- /dev/null +++ b/lib/gwen/controls/gwen_labelclickable.cpp @@ -0,0 +1,26 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_labelclickable.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( LabelClickable ) +{ + SetIsToggle( false ); + + SetCursor( Gwen::CursorType::Finger ); + SetAlignment( Gwen::Pos::Left | Gwen::Pos::CenterV ); +} + +void LabelClickable::Render( Skin::Base* /*skin*/ ) +{ + //skin->DrawButton( this, IsDepressed(), IsToggle() && GetToggleState() ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_labelclickable.h b/lib/gwen/controls/gwen_labelclickable.h new file mode 100644 index 0000000..86b9d22 --- /dev/null +++ b/lib/gwen/controls/gwen_labelclickable.h @@ -0,0 +1,29 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LABELCLICKABLE_H +#define GWEN_CONTROLS_LABELCLICKABLE_H + +#include "gwen_base.h" +#include "gwen_button.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT LabelClickable : public Button + { + public: + + GWEN_CONTROL( LabelClickable, Button ); + + virtual void Render( Skin::Base* skin ); + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_listbox.cpp b/lib/gwen/controls/gwen_listbox.cpp new file mode 100644 index 0000000..c8415d7 --- /dev/null +++ b/lib/gwen/controls/gwen_listbox.cpp @@ -0,0 +1,182 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_listbox.h" +#include "gwen_scrollcontrol.h" +#include "../gwen_inputhandler.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class ListBoxRow : public Layout::TableRow +{ + GWEN_CONTROL_INLINE( ListBoxRow, Layout::TableRow ) + { + SetMouseInputEnabled( true ); + SetSelected( false ); + } + + void Render( Skin::Base* skin ) + { + skin->DrawListBoxLine( this, IsSelected(), GetEven() ); + } + + bool IsSelected() const + { + return m_bSelected; + } + + void OnMouseClickLeft( int /*x*/, int /*y*/, bool bDown ) + { + if ( bDown ) + { + SetSelected( true ); + onRowSelected.Call( this ); + Redraw(); + } + } + + void SetSelected( bool b ) + { + m_bSelected = b; + + // TODO: Get these values from the skin. + if ( b ) + SetTextColor( Gwen::Colors::White ); + else + SetTextColor( Gwen::Colors::Black ); + } + + private: + + bool m_bSelected; + +}; + +GWEN_CONTROL_CONSTRUCTOR( ListBox ) +{ + SetScroll( false, true ); + SetAutoHideBars( true ); + SetMargin( Margin( 1, 1, 1, 1 ) ); + m_InnerPanel->SetPadding( Padding( 2, 2, 2, 2 ) ); + + m_Table = new Controls::Layout::Table( this ); + m_Table->SetColumnCount( 1 ); + + m_bMultiSelect = false; +} + +Layout::TableRow* ListBox::AddItem( const TextObject& strLabel, const String& strName ) +{ + ListBoxRow* pRow = new ListBoxRow( this ); + m_Table->AddRow( pRow ); + + pRow->SetCellText( 0, strLabel ); + pRow->SetName( strName ); + + pRow->onRowSelected.Add( this, &ListBox::OnRowSelected ); + return pRow; +} + +void ListBox::RemoveItem( Layout::TableRow * row ) +{ + m_SelectedRows.erase( stl::find( m_SelectedRows.begin(), m_SelectedRows.end(), row ) ); + m_Table->Remove( row ); +} + +void ListBox::Render( Skin::Base* skin ) +{ + skin->DrawListBox( this ); +} + +void ListBox::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + const Gwen::Rect& inner = m_InnerPanel->GetInnerBounds(); + + m_Table->SetPos( inner.x, inner.y ); + m_Table->SetWidth( inner.w ); + m_Table->SizeToChildren( false, true ); + + BaseClass::Layout( skin ); +} + +void ListBox::UnselectAll() +{ + stl::list::iterator it = m_SelectedRows.begin(); + while ( it != m_SelectedRows.end() ) + { + ListBoxRow* pRow = static_cast(*it); + it = m_SelectedRows.erase( it ); + + pRow->SetSelected( false ); + } +} + +void ListBox::OnRowSelected( Base* pControl ) +{ + bool bClear = !Gwen::Input::IsShiftDown(); + if ( !AllowMultiSelect() ) bClear = true; + + SetSelectedRow( pControl, bClear ); +} + +Layout::TableRow* ListBox::GetSelectedRow() +{ + if ( m_SelectedRows.empty() ) return NULL; + + return *m_SelectedRows.begin(); +} + +Gwen::String ListBox::GetSelectedRowName() +{ + Layout::TableRow* row = GetSelectedRow(); + if ( !row ) return ""; + + return row->GetName(); +} + +void ListBox::Clear() +{ + UnselectAll(); + m_Table->Clear(); +} + +void ListBox::SetSelectedRow( Gwen::Controls::Base* pControl, bool bClearOthers ) +{ + if ( bClearOthers ) + UnselectAll(); + + ListBoxRow* pRow = gwen_cast( pControl ); + if ( !pRow ) return; + + // TODO: make sure this is one of our rows! + + pRow->SetSelected( true ); + m_SelectedRows.push_back( pRow ); + onRowSelected.Call( this ); +} + + + +void ListBox::SelectByString( const TextObject& strName, bool bClearOthers ) +{ + if ( bClearOthers ) + UnselectAll(); + + Base::List& children = m_Table->GetChildren(); + + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + ListBoxRow* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + if ( Utility::Strings::Wildcard( strName, pChild->GetText( 0 ) ) ) + SetSelectedRow( pChild, false ); + } +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_listbox.h b/lib/gwen/controls/gwen_listbox.h new file mode 100644 index 0000000..58739eb --- /dev/null +++ b/lib/gwen/controls/gwen_listbox.h @@ -0,0 +1,71 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LISTBOX_H +#define GWEN_CONTROLS_LISTBOX_H + +#include "../gwen.h" +#include "layout/gwen_table.h" +#include "gwen_scrollcontrol.h" + + +namespace Gwen +{ + namespace Controls + { + class ScrollControl; + + class GWEN_EXPORT ListBox : public ScrollControl + { + public: + + GWEN_CONTROL( ListBox, ScrollControl ); + + typedef stl::list Rows; + + Layout::TableRow* AddItem( const TextObject& strLabel, const String& strName = "" ); + + void RemoveItem( Layout::TableRow * row ); + + void Render( Skin::Base* skin ); + void Layout( Skin::Base* skin ); + + void UnselectAll(); + + void SetAllowMultiSelect( bool bMultiSelect ){ m_bMultiSelect = bMultiSelect; } + bool AllowMultiSelect() const { return m_bMultiSelect; } + + const ListBox::Rows& GetSelectedRows(){ return m_SelectedRows; } + + virtual Layout::TableRow* GetSelectedRow(); + virtual Gwen::String GetSelectedRowName(); + + virtual void SetSelectedRow( Gwen::Controls::Base* pRow, bool bClearOthers = true ); + virtual void SelectByString( const TextObject& string, bool bClearOthers = true ); + + Gwen::Event::Caller onRowSelected; + + Controls::Layout::Table* GetTable() { return m_Table; } + virtual void Clear(); + + // Pass through, to embedded table + void SetColumnCount( int iCount ) { m_Table->SetColumnCount( iCount ); } + void SetColumnWidth( int iCount, int iSize ) { m_Table->SetColumnWidth( iCount, iSize ); } + + protected: + + + void OnRowSelected( Base* pControl ); + + Controls::Layout::Table* m_Table; + ListBox::Rows m_SelectedRows; + + bool m_bMultiSelect; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_menu.cpp b/lib/gwen/controls/gwen_menu.cpp new file mode 100644 index 0000000..2b79fd8 --- /dev/null +++ b/lib/gwen/controls/gwen_menu.cpp @@ -0,0 +1,178 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_menu.h" +#include "../gwen_skin.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + + + +GWEN_CONTROL_CONSTRUCTOR( Menu ) +{ + SetBounds( 0, 0, 10, 10 ); + SetPadding( Padding( 2, 2, 2, 2 ) ); + + SetDisableIconMargin( false ); + + SetAutoHideBars( true ); + SetScroll( false, true ); + SetDeleteOnClose( false ); +} + + +void Menu::Render( Skin::Base* skin ) +{ + skin->DrawMenu( this, IconMarginDisabled() ); +} + +void Menu::RenderUnder( Skin::Base* skin ) +{ + BaseClass::RenderUnder( skin ); + skin->DrawShadow( this ); +} + +void Menu::Layout( Skin::Base* skin ) +{ + int childrenHeight = 0; + for ( Base::List::iterator it = m_InnerPanel->Children.begin(); it != m_InnerPanel->Children.end(); ++it ) + { + Base* pChild = (*it); + if ( !pChild ) + continue; + + childrenHeight += pChild->Height(); + } + + if ( Y() + childrenHeight > GetCanvas()->Height() ) + childrenHeight = GetCanvas()->Height() - Y(); + + SetSize( Width(), childrenHeight ); + + BaseClass::Layout( skin ); +} + +MenuItem* Menu::AddItem( const TextObject& strName, const TextObject& strIconName, const TextObject& strAccelerator ) +{ + MenuItem* pItem = new MenuItem( this ); + + pItem->SetPadding( Padding( 2, 4, 4, 4 ) ); + pItem->SetText( strName ); + pItem->SetImage( strIconName ); + pItem->SetAccelerator( strAccelerator ); + + OnAddItem( pItem ); + + return pItem; +} + +void Menu::OnAddItem( MenuItem* item ) +{ + item->SetTextPadding( Padding( IconMarginDisabled() ? 0 : 24, 0, 16, 0 ) ); + item->Dock( Pos::Top ); + item->SizeToContents(); + item->SetAlignment( Pos::CenterV | Pos::Left ); + item->onHoverEnter.Add( this, &Menu::OnHoverItem ); + + // Do this here - after Top Docking these values mean nothing in layout + int w = item->Width() + 10 + 32; + if ( w < Width() ) w = Width(); + SetSize( w, Height() ); +} + +void Menu::ClearItems() +{ + for ( Base::List::iterator it = m_InnerPanel->Children.begin(); it != m_InnerPanel->Children.end(); ++it ) + { + Base* pChild = *it; + + if ( !pChild ) continue; + pChild->DelayedDelete(); + } +} + +void Menu::CloseAll() +{ + for ( Base::List::iterator it = m_InnerPanel->Children.begin(); it != m_InnerPanel->Children.end(); ++it ) + { + Base* pChild = *it; + MenuItem* pItem = gwen_cast(pChild); + if ( !pItem ) continue; + + pItem->CloseMenu(); + } +} + +bool Menu::IsMenuOpen() +{ + for ( Base::List::iterator it = m_InnerPanel->Children.begin(); it != m_InnerPanel->Children.end(); ++it ) + { + Base* pChild = *it; + MenuItem* pItem = gwen_cast(pChild); + if ( !pItem ) continue; + + if ( pItem->IsMenuOpen() ) + return true; + } + + return false; +} + +void Menu::OnHoverItem( Gwen::Controls::Base* pControl ) +{ + if ( !ShouldHoverOpenMenu() ) return; + + MenuItem* pItem = gwen_cast(pControl); + if (!pItem) return; + if ( pItem->IsMenuOpen() ) return; + + CloseAll(); + pItem->OpenMenu(); +} + +void Menu::Open( unsigned int iPos ) +{ + SetHidden( false ); + BringToFront(); + + Gwen::Point MousePos = Input::GetMousePosition(); + SetPos( MousePos.x, MousePos.y ); +} + +void Menu::Close() +{ + SetHidden( true ); + + if ( DeleteOnClose() ) + { + DelayedDelete(); + } +} + +void Menu::CloseMenus() +{ + BaseClass::CloseMenus(); + + CloseAll(); + Close(); +} + +void Menu::AddDivider() +{ + MenuDivider* divider = new MenuDivider( this ); + divider->Dock( Pos::Top ); + divider->SetMargin( Margin( IconMarginDisabled() ? 0 : 24, 0, 4, 0 ) ); +} + +void MenuDivider::Render( Gwen::Skin::Base* skin ) +{ + skin->DrawMenuDivider( this ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_menu.h b/lib/gwen/controls/gwen_menu.h new file mode 100644 index 0000000..f4ca302 --- /dev/null +++ b/lib/gwen/controls/gwen_menu.h @@ -0,0 +1,78 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_MENU_H +#define GWEN_CONTROLS_MENU_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_menuitem.h" +#include "gwen_scrollcontrol.h" + +namespace Gwen +{ + namespace Controls + { + class MenuItem; + + class GWEN_EXPORT Menu : public ScrollControl + { + public: + + GWEN_CONTROL( Menu, ScrollControl ); + + virtual void Render( Skin::Base* skin ); + virtual void RenderUnder( Skin::Base* skin ); + + virtual void Layout( Skin::Base* skin ); + + virtual MenuItem* AddItem( const TextObject& strName, const TextObject& strIconName = "", const TextObject& strAccelerator = "" ); + + virtual void AddDivider(); + + void OnHoverItem( Gwen::Controls::Base* pControl ); + void CloseAll(); + bool IsMenuOpen(); + void ClearItems(); + + virtual void Open( unsigned int iPos ); + virtual void Close(); + + virtual bool IsMenuComponent(){ return true; } + virtual void CloseMenus(); + + bool IconMarginDisabled() { return m_bDisableIconMargin; } + void SetDisableIconMargin( bool bDisable ) { m_bDisableIconMargin = bDisable; } + + bool DeleteOnClose() { return m_bDeleteOnClose; } + void SetDeleteOnClose( bool b ) { m_bDeleteOnClose = b; } + + + protected: + + virtual bool ShouldHoverOpenMenu(){ return true; } + virtual void OnAddItem( MenuItem* item ); + + bool m_bDisableIconMargin; + bool m_bDeleteOnClose; + }; + + class GWEN_EXPORT MenuDivider : public Base + { + public: + + GWEN_CONTROL_INLINE( MenuDivider, Base ) + { + SetHeight( 1 ); + } + + void Render( Gwen::Skin::Base* skin ); + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_menuitem.cpp b/lib/gwen/controls/gwen_menuitem.cpp new file mode 100644 index 0000000..44b345e --- /dev/null +++ b/lib/gwen/controls/gwen_menuitem.cpp @@ -0,0 +1,194 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_menuitem.h" +#include "../gwen_skin.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class GWEN_EXPORT RightArrow : public Controls::Base +{ + public: + + GWEN_CONTROL_INLINE( RightArrow, Controls::Base ) + { + SetMouseInputEnabled( false ); + } + + void Render( Skin::Base* skin ) + { + skin->DrawMenuRightArrow( this ); + } +}; + +GWEN_CONTROL_CONSTRUCTOR( MenuItem ) +{ + m_Menu = NULL; + m_bOnStrip = false; + m_SubmenuArrow = NULL; + m_Accelerator = NULL; + SetTabable( false ); + SetCheckable( false ); + SetChecked( false ); +} + +MenuItem::~MenuItem() +{ + +} + +void MenuItem::Render( Skin::Base* skin ) +{ + skin->DrawMenuItem( this, IsMenuOpen(), m_bCheckable ? m_bChecked : false ); + + // HACK! + if ( m_Accelerator ) + { + m_Accelerator->SetTextColorOverride( TextColor() ); + } +} + +void MenuItem::Layout( Skin::Base* skin ) +{ + if ( m_SubmenuArrow ) + { + m_SubmenuArrow->Position( Pos::Right | Pos::CenterV, 4, 0 ); + } + + BaseClass::Layout( skin ); +} + + + +Menu* MenuItem::GetMenu() +{ + if ( !m_Menu ) + { + m_Menu = new Menu( GetCanvas() ); + m_Menu->SetHidden( true ); + + if ( !m_bOnStrip ) + { + m_SubmenuArrow = new RightArrow( this ); + m_SubmenuArrow->SetSize( 15, 15 ); + } + + Invalidate(); + } + + return m_Menu; +} + +void MenuItem::SetChecked( bool bCheck ) +{ + if ( bCheck == m_bChecked) + return; + + m_bChecked = bCheck; + + onCheckChange.Call( this ); + + if ( bCheck ) + onChecked.Call( this ); + else + onUnChecked.Call( this ); +} + +void MenuItem::OnPress() +{ + if ( m_Menu ) + { + ToggleMenu(); + } + else if ( !m_bOnStrip ) + { + SetChecked( !GetChecked() ); + onMenuItemSelected.Call( this ); + GetCanvas()->CloseMenus(); + } + + BaseClass::OnPress(); +} + +void MenuItem::ToggleMenu() +{ + if ( IsMenuOpen() ) CloseMenu(); + else OpenMenu(); +} + +bool MenuItem::IsMenuOpen() +{ + if ( !m_Menu ) return false; + + return !m_Menu->Hidden(); +} + +void MenuItem::OpenMenu() +{ + if ( !m_Menu ) return; + + m_Menu->SetHidden( false ); + m_Menu->BringToFront(); + + Gwen::Point p = LocalPosToCanvas( Gwen::Point( 0, 0 ) ); + + // Strip menus open downwards + if ( m_bOnStrip ) + { + m_Menu->SetPos( p.x, p.y + Height() + 1 ); + } + // Submenus open sidewards + else + { + m_Menu->SetPos( p.x + Width(), p.y); + } + + // TODO: Option this. + // TODO: Make sure on screen, open the other side of the + // parent if it's better... + + +} + +void MenuItem::CloseMenu() +{ + if ( !m_Menu ) return; + m_Menu->Close(); + m_Menu->CloseAll(); +} + +void MenuItem::SetAccelerator( const TextObject& strAccelerator ) +{ + if ( m_Accelerator ) + { + m_Accelerator->DelayedDelete(); + m_Accelerator = NULL; + } + + if ( strAccelerator.Get() == "" ) + return; + + m_Accelerator = new Controls::Label( this ); + m_Accelerator->Dock( Pos::Right ); + m_Accelerator->SetAlignment( Pos::Right | Pos::CenterV ); + m_Accelerator->SetText( strAccelerator ); + m_Accelerator->SetMargin( Margin( 0, 0, 16, 0 ) ); + // TODO. +} + +void MenuItem::SizeToContents() +{ + BaseClass::SizeToContents(); + + if ( m_Accelerator ) + { + m_Accelerator->SizeToContents(); + SetWidth( Width() + m_Accelerator->Width() ); + } +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_menuitem.h b/lib/gwen/controls/gwen_menuitem.h new file mode 100644 index 0000000..6725543 --- /dev/null +++ b/lib/gwen/controls/gwen_menuitem.h @@ -0,0 +1,81 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_MENUITEM_H +#define GWEN_CONTROLS_MENUITEM_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_menu.h" + +namespace Gwen +{ + namespace Controls + { + class Menu; + + class GWEN_EXPORT MenuItem : public Button + { + public: + + GWEN_CONTROL( MenuItem, Button ); + + virtual ~MenuItem(); + + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + + virtual void SizeToContents(); + + virtual void OnPress(); + + Menu* GetMenu(); + + bool IsMenuOpen(); + void OpenMenu(); + void CloseMenu(); + void ToggleMenu(); + + void SetOnStrip( bool b ){ m_bOnStrip = b;} + bool OnStrip(){ return m_bOnStrip; } + + virtual void SetCheckable( bool bCheck ) { m_bCheckable = bCheck; } + virtual void SetChecked( bool bCheck ); + virtual bool GetChecked() { return m_bChecked; } + + template + MenuItem* SetAction( Gwen::Event::Handler* pHandler, T fn ) + { + if ( m_Accelerator ) AddAccelerator( m_Accelerator->GetText(), fn, pHandler ); + onMenuItemSelected.Add( pHandler, fn ); + return this; + } + + void SetAccelerator( const TextObject& strAccelerator ); + + Gwen::Event::Caller onMenuItemSelected; + Gwen::Event::Caller onChecked; + Gwen::Event::Caller onUnChecked; + Gwen::Event::Caller onCheckChange; + + private: + + Menu* m_Menu; + bool m_bOnStrip; + bool m_bCheckable; + bool m_bChecked; + + Label* m_Accelerator; + + + Controls::Base * m_SubmenuArrow; + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_menustrip.cpp b/lib/gwen/controls/gwen_menustrip.cpp new file mode 100644 index 0000000..fb31e59 --- /dev/null +++ b/lib/gwen/controls/gwen_menustrip.cpp @@ -0,0 +1,45 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_menustrip.h" +#include "../gwen_skin.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( MenuStrip ) +{ + SetBounds( 0, 0, 200, 22 ); + Dock( Pos::Top ); + m_InnerPanel->SetPadding( Padding( 5, 0, 0, 0 ) ); +} + +void MenuStrip::Render( Skin::Base* skin ) +{ + skin->DrawMenuStrip( this ); +} + +void MenuStrip::Layout( Skin::Base* /*skin*/ ) +{ + //TODO: We don't want to do vertical sizing the same as Menu, do nothing for now +} + +void MenuStrip::OnAddItem( MenuItem* item ) +{ + item->Dock( Pos::Left ); + item->SetTextPadding( Padding( 5, 0, 5, 0 ) ); + item->SetPadding( Padding( 10, 0, 10, 0 ) ); + item->SizeToContents(); + item->SetOnStrip( true ); + item->onHoverEnter.Add( this, &Menu::OnHoverItem ); +} + +bool MenuStrip::ShouldHoverOpenMenu() +{ + return IsMenuOpen(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_menustrip.h b/lib/gwen/controls/gwen_menustrip.h new file mode 100644 index 0000000..98bcf60 --- /dev/null +++ b/lib/gwen/controls/gwen_menustrip.h @@ -0,0 +1,39 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_MENUSTRIP_H +#define GWEN_CONTROLS_MENUSTRIP_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_menu.h" +#include "gwen_menuitem.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT MenuStrip : public Menu + { + GWEN_CONTROL( MenuStrip, Menu ); + + virtual void Render( Skin::Base* skin ); + virtual void RenderUnder( Skin::Base* /*skin*/ ){} + virtual void Layout( Skin::Base* skin ); + + protected: + + virtual void OnAddItem( MenuItem* item ); + virtual bool ShouldHoverOpenMenu(); + virtual void Close() {} + + + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_modal.h b/lib/gwen/controls/gwen_modal.h new file mode 100644 index 0000000..adfcf17 --- /dev/null +++ b/lib/gwen/controls/gwen_modal.h @@ -0,0 +1,37 @@ +#pragma once +#ifndef GWEN_CONTROLS_MODAL_H +#define GWEN_CONTROLS_MODAL_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace ControlsInternal + { + class Modal : public Controls::Base + { + GWEN_CONTROL_INLINE( Modal, Controls::Base ) + { + SetKeyboardInputEnabled( true ); + SetMouseInputEnabled( true ); + SetShouldDrawBackground( true ); + + SetBounds( 0, 0, GetParent()->Width(), GetParent()->Height() ); + } + + virtual void Layout( Skin::Base* /*skin*/ ) + { + SetBounds( 0, 0, GetCanvas()->Width(), GetCanvas()->Height() ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawModalControl( this ); + } + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_numericupdown.cpp b/lib/gwen/controls/gwen_numericupdown.cpp new file mode 100644 index 0000000..fb907b1 --- /dev/null +++ b/lib/gwen/controls/gwen_numericupdown.cpp @@ -0,0 +1,116 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_utility.h" +#include "../gwen_skin.h" +#include "gwen_numericupdown.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( NumericUpDown ) +{ + SetSize( 100, 20 ); + + Controls::Base* pSplitter = new Controls::Base( this ); + pSplitter->Dock( Pos::Right ); + pSplitter->SetWidth( 13 ); + + NumericUpDownButton_Up* pButtonUp = new NumericUpDownButton_Up( pSplitter ); + pButtonUp->onPress.Add( this, &NumericUpDown::OnButtonUp ); + pButtonUp->SetTabable( false ); + pButtonUp->Dock( Pos::Top ); + pButtonUp->SetHeight( 10 ); + + NumericUpDownButton_Down* pButtonDown = new NumericUpDownButton_Down( pSplitter ); + pButtonDown->onPress.Add( this, &NumericUpDown::OnButtonDown ); + pButtonDown->SetTabable( false ); + pButtonDown->Dock( Pos::Fill ); + pButtonUp->SetPadding( Padding( 0, 1, 1, 0 ) ); + + m_iMax = 100; + m_iMin = 0; + m_iNumber = 0; + SetText( "0" ); +} + +void NumericUpDown::OnButtonUp( Base* /*control*/ ) +{ + SyncNumberFromText(); + SetValue( m_iNumber + 1 ); +} + +void NumericUpDown::OnButtonDown( Base* /*control*/ ) +{ + SyncNumberFromText(); + SetValue( m_iNumber - 1 ); +} + + +void NumericUpDown::SyncTextFromNumber() +{ + SetText( Utility::ToString( m_iNumber ) ); +} + +void NumericUpDown::SyncNumberFromText() +{ + SetValue( (int) GetFloatFromText() ); +} + +void NumericUpDown::SetMin( int i ) +{ + m_iMin = i; +} + +void NumericUpDown::SetMax( int i ) +{ + m_iMax = i; +} + +void NumericUpDown::SetValue( int i ) +{ + if ( i > m_iMax ) i = m_iMax; + if ( i < m_iMin ) i = m_iMin; + + if ( m_iNumber == i ) + { + return; + } + + m_iNumber = i; + + // Don't update the text if we're typing in it.. + // Undone - any reason why not? + //if ( !HasFocus() ) + { + SyncTextFromNumber(); + } + + OnChange(); +} + +void NumericUpDown::OnChange() +{ + onChanged.Call( this ); +} + +void NumericUpDown::OnTextChanged() +{ + BaseClass::OnTextChanged(); + + SyncNumberFromText(); +} + +void NumericUpDown::OnEnter() +{ + SyncNumberFromText(); + SyncTextFromNumber(); + + BaseClass::OnEnter(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_numericupdown.h b/lib/gwen/controls/gwen_numericupdown.h new file mode 100644 index 0000000..558ad67 --- /dev/null +++ b/lib/gwen/controls/gwen_numericupdown.h @@ -0,0 +1,81 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_NUMERICUPDOWN_H +#define GWEN_CONTROLS_NUMERICUPDOWN_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_textbox.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT NumericUpDownButton_Up : public Button + { + GWEN_CONTROL_INLINE( NumericUpDownButton_Up, Button ) + { + SetSize( 7, 7 ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawNumericUpDownButton( this, IsDepressed(), true ); + } + }; + + class GWEN_EXPORT NumericUpDownButton_Down : public Button + { + GWEN_CONTROL_INLINE( NumericUpDownButton_Down, Button ) + { + SetSize( 7, 7 ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawNumericUpDownButton( this, IsDepressed(), false ); + } + }; + + class GWEN_EXPORT NumericUpDown : public TextBoxNumeric + { + public: + + GWEN_CONTROL( NumericUpDown, TextBoxNumeric ); + + virtual void SetMin( int i ); + virtual void SetMax( int i ); + virtual void SetValue( int i ); + + Event::Caller onChanged; + + private: + + virtual void OnEnter(); + virtual void OnChange(); + virtual void OnTextChanged(); + + virtual void OnButtonUp( Base* control ); + virtual void OnButtonDown( Base* control ); + + virtual bool OnKeyUp( bool bDown ) { if ( bDown ) OnButtonUp( NULL ); return true; } + virtual bool OnKeyDown( bool bDown ){ if ( bDown ) OnButtonDown( NULL ); return true; } + + virtual void SyncTextFromNumber(); + virtual void SyncNumberFromText(); + + + + int m_iNumber; + int m_iMax; + int m_iMin; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_pagecontrol.cpp b/lib/gwen/controls/gwen_pagecontrol.cpp new file mode 100644 index 0000000..b139cb5 --- /dev/null +++ b/lib/gwen/controls/gwen_pagecontrol.cpp @@ -0,0 +1,176 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_utility.h" +#include "../gwen_skin.h" +#include "gwen_pagecontrol.h" +#include "../gwen_controls.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( PageControl ) +{ + m_iPages = 0; + m_iCurrentPage = 0; + SetUseFinishButton( true ); + + for (unsigned int i=0; iDock( Pos::Bottom ); + pControls->SetSize( 24, 24 ); + pControls->SetMargin( Margin( 10, 10, 10, 10 ) ); + + m_Finish = new Controls::Button( pControls ); + m_Finish->SetText( "Finish" ); + m_Finish->Dock( Pos::Right ); + m_Finish->onPress.Add( this, &ThisClass::Finish ); + m_Finish->SetSize( 70 ); + m_Finish->SetMargin( Margin( 4, 0, 0, 0 ) ); + m_Finish->Hide(); + + m_Next = new Controls::Button( pControls ); + m_Next->SetText( "Next >" ); + m_Next->Dock( Pos::Right ); + m_Next->onPress.Add( this, &ThisClass::NextPage ); + m_Next->SetSize( 70 ); + m_Next->SetMargin( Margin( 4, 0, 0, 0 ) ); + + m_Back = new Controls::Button( pControls ); + m_Back->SetText( "< Back" ); + m_Back->Dock( Pos::Right ); + m_Back->onPress.Add( this, &ThisClass::PreviousPage ); + m_Back->SetSize( 70 ); + + m_Label = new Controls::Label( pControls ); + m_Label->Dock( Pos::Fill ); + m_Label->SetAlignment( Pos::Left | Pos::CenterV ); + m_Label->SetText( "Page 1 or 2" ); +} + +void PageControl::SetPageCount( unsigned int iNum ) +{ + if ( iNum >= MaxPages ) iNum = MaxPages; + + for (unsigned int i=0; iDock( Pos::Fill ); + } + } + + m_iPages = iNum; + + // Setting to -1 to force the page to change + m_iCurrentPage = -1; + HideAll(); + ShowPage( 0 ); +} + +void PageControl::HideAll() +{ + for (unsigned int i=0; iHide(); + } +} + +void PageControl::ShowPage( unsigned int i ) +{ + if ( m_iCurrentPage == i ) return; + + if ( m_pPages[i] ) + { + m_pPages[i]->Show(); + m_pPages[i]->Dock( Pos::Fill ); + } + + m_iCurrentPage = i; + + m_Back->SetDisabled( m_iCurrentPage == 0 ); + m_Next->SetDisabled( m_iCurrentPage >= m_iPages ); + + m_Label->SetText( Utility::Format( "Page %i of %i", m_iCurrentPage+1, m_iPages ) ); + + if ( GetUseFinishButton() ) + { + bool bFinished = m_iCurrentPage >= m_iPages-1; + m_Next->SetHidden( bFinished ); + m_Finish->SetHidden( !bFinished ); + } + + { + Event::Information info; + info.Integer = i; + info.Control = m_pPages[i]; + + onPageChanged.Call( this, info ); + } +} + +Controls::Base* PageControl::GetPage( unsigned int i ) +{ + return m_pPages[i]; +} + +Controls::Base* PageControl::GetCurrentPage() +{ + return GetPage( GetPageNumber() ); +} + +void PageControl::NextPage() +{ + if ( m_iCurrentPage >= m_iPages-1 ) return; + + if ( m_pPages[m_iCurrentPage] ) + { + m_pPages[m_iCurrentPage]->Dock( Pos::None ); + Anim::Add( m_pPages[m_iCurrentPage], new Anim::Pos::X( m_pPages[m_iCurrentPage]->X(), Width() * -1, 0.2f, true, 0.0f, -1 ) ); + } + + ShowPage( m_iCurrentPage + 1 ); + + if ( m_pPages[m_iCurrentPage] ) + { + m_pPages[m_iCurrentPage]->Dock( Pos::None ); + Anim::Add( m_pPages[m_iCurrentPage], new Anim::Pos::X( Width(), 0, 0.2f, false, 0.0f, -1 ) ); + } +} + +void PageControl::PreviousPage() +{ + if ( m_iCurrentPage == 0 ) return; + + if ( m_pPages[m_iCurrentPage] ) + { + m_pPages[m_iCurrentPage]->Dock( Pos::None ); + Anim::Add( m_pPages[m_iCurrentPage], new Anim::Pos::X( m_pPages[m_iCurrentPage]->X(), Width(), 0.3f, true, 0.0f, -1 ) ); + } + + ShowPage( m_iCurrentPage - 1 ); + + if ( m_pPages[m_iCurrentPage] ) + { + m_pPages[m_iCurrentPage]->Dock( Pos::None ); + Anim::Add( m_pPages[m_iCurrentPage], new Anim::Pos::X( Width() * -1, 0, 0.3f, false, 0.0f, -1 ) ); + } +} + +void PageControl::Finish() +{ + onFinish.Call( this ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_pagecontrol.h b/lib/gwen/controls/gwen_pagecontrol.h new file mode 100644 index 0000000..0cea6f7 --- /dev/null +++ b/lib/gwen/controls/gwen_pagecontrol.h @@ -0,0 +1,66 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PAGECONTROL_H +#define GWEN_CONTROLS_PAGECONTROL_H + +#include "gwen_base.h" +#include "gwen_button.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT PageControl : public Base + { + static const unsigned int MaxPages = 64; + + GWEN_CONTROL( PageControl, Base ); + + virtual void SetPageCount( unsigned int i ); + virtual unsigned int GetPageCount(){ return m_iPages; } + + virtual void ShowPage( unsigned int i ); + virtual unsigned int GetPageNumber(){ return m_iCurrentPage; } + virtual Controls::Base* GetPage( unsigned int i ); + virtual Controls::Base* GetCurrentPage(); + + virtual void NextPage(); + virtual void PreviousPage(); + virtual void Finish(); + + Controls::Button* NextButton(){ return m_Next; } + Controls::Button* BackButton(){ return m_Back; } + Controls::Button* FinishButton(){ return m_Finish; } + Controls::Label* Label(){ return m_Label; } + + void SetUseFinishButton( bool b ){ m_bFinish = b; } + bool GetUseFinishButton(){ return m_bFinish; } + + Event::Caller onPageChanged; + Event::Caller onFinish; + + protected: + + virtual void HideAll(); + + unsigned int m_iCurrentPage; + unsigned int m_iPages; + Controls::Base* m_pPages[MaxPages]; + + Controls::Button* m_Next; + Controls::Button* m_Back; + Controls::Button* m_Finish; + Controls::Label* m_Label; + + bool m_bFinish; + + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_panel.cpp b/lib/gwen/controls/gwen_panel.cpp new file mode 100644 index 0000000..ad4d4c0 --- /dev/null +++ b/lib/gwen/controls/gwen_panel.cpp @@ -0,0 +1,20 @@ +/* + Control added by Gered King (May 2012) +*/ + + +#include "gwen_panel.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( Panel ) +{ + m_iPanelStyle = Gwen::Skin::Panel::Normal; +} + +void Panel::Render( Skin::Base* skin ) +{ + skin->DrawPanel(this, m_iPanelStyle); +} diff --git a/lib/gwen/controls/gwen_panel.h b/lib/gwen/controls/gwen_panel.h new file mode 100644 index 0000000..0eaefaa --- /dev/null +++ b/lib/gwen/controls/gwen_panel.h @@ -0,0 +1,35 @@ +/* + Control added by Gered King (May 2012) +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PANEL_H +#define GWEN_CONTROLS_PANEL_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT Panel : public Controls::Base + { + public: + + GWEN_CONTROL( Panel, Controls::Base ); + + virtual void Render( Skin::Base* skin ); + + void SetStyle(unsigned char iPanelStyle) { m_iPanelStyle = iPanelStyle; } + unsigned char GetStyle() const { return m_iPanelStyle; } + + private: + unsigned char m_iPanelStyle; + }; + } +} +#endif + diff --git a/lib/gwen/controls/gwen_progressbar.cpp b/lib/gwen/controls/gwen_progressbar.cpp new file mode 100644 index 0000000..2b03ee8 --- /dev/null +++ b/lib/gwen/controls/gwen_progressbar.cpp @@ -0,0 +1,98 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollcontrol.h" +#include "gwen_progressbar.h" +#include "../gwen_anim.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class ProgressBarThink : public Gwen::Anim::Animation +{ + public: + + ProgressBarThink() + { + m_fLastFrame = 0.0f; + } + + virtual void Think() + { + float fDiff = Platform::GetTimeInSeconds() - m_fLastFrame; + + gwen_cast(m_Control)->CycleThink( Gwen::Clamp( fDiff, 0, 0.3 ) ); + + m_fLastFrame = Platform::GetTimeInSeconds(); + } + + + float m_fLastFrame; +}; + + +GWEN_CONTROL_CONSTRUCTOR( ProgressBar ) +{ + SetMouseInputEnabled( true ); + SetBounds( Gwen::Rect( 0, 0, 128, 32 ) ); + SetTextPadding( Padding( 3, 3, 3, 3 ) ); + SetHorizontal(); + + SetAlignment( Gwen::Pos::Center ); + + m_fProgress = 0.0f; + m_bAutoLabel = true; + m_fCycleSpeed = 0.0f; + + Gwen::Anim::Add( this, new ProgressBarThink() ); +} + +void ProgressBar::SetValue(float val) +{ + if ( val < 0 ) + val = 0; + + if ( val > 1 ) + val = 1; + + m_fProgress = val; + + if ( m_bAutoLabel ) + { + int displayVal = m_fProgress * 100; + SetText( Utility::ToString( displayVal ) + "%" ); + } +} + +void ProgressBar::CycleThink( float fDelta ) +{ + if ( !Visible() ) return; + if ( m_fCycleSpeed == 0.0f ) return; + + m_fProgress += m_fCycleSpeed * fDelta; + + if ( m_fProgress < 0.0f ) m_fProgress += 1.0f; + if ( m_fProgress > 1.0f ) m_fProgress -= 1.0f; + + Redraw(); +} + +void ProgressBar::Render( Skin::Base* skin ) +{ + skin->DrawProgressBar( this, m_bHorizontal, m_fProgress); +} + +float ProgressBar::GetCycleSpeed() +{ + return m_fCycleSpeed; +} + +void ProgressBar::SetCycleSpeed( float f ) +{ + m_fCycleSpeed = f; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_progressbar.h b/lib/gwen/controls/gwen_progressbar.h new file mode 100644 index 0000000..e79b244 --- /dev/null +++ b/lib/gwen/controls/gwen_progressbar.h @@ -0,0 +1,51 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROGRESSBAR_H +#define GWEN_CONTROLS_PROGRESSBAR_H +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT ProgressBar : public Label + { + public: + + GWEN_CONTROL( ProgressBar, Label ); + + virtual void Render( Skin::Base* skin ); + + virtual void SetVertical() { m_bHorizontal = false; } + virtual void SetHorizontal(){ m_bHorizontal = true; } + + virtual void SetValue( float val ); + virtual float GetValue() const { return m_fProgress; } + + virtual void SetAutoLabel( bool b ){ m_bAutoLabel = b; } + + virtual float GetCycleSpeed(); + virtual void SetCycleSpeed( float f ); + + virtual void CycleThink( float fDelta ); + + protected: + + float m_fProgress; + float m_fCycleSpeed; + + bool m_bHorizontal; + bool m_bAutoLabel; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_properties.cpp b/lib/gwen/controls/gwen_properties.cpp new file mode 100644 index 0000000..2c45d71 --- /dev/null +++ b/lib/gwen/controls/gwen_properties.cpp @@ -0,0 +1,183 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_properties.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( Properties ) +{ + m_SplitterBar = new SplitterBar( this ); + m_SplitterBar->SetPos( 80, 0 ); + m_SplitterBar->SetCursor( Gwen::CursorType::SizeWE ); + m_SplitterBar->onDragged.Add( this, &Properties::OnSplitterMoved ); + m_SplitterBar->SetShouldDrawBackground( false ); + m_SplitterBar->DoNotIncludeInSize(); +} + +void Properties::PostLayout( Gwen::Skin::Base* /*skin*/ ) +{ + if ( SizeToChildren( false, true ) ) + { + InvalidateParent(); + } + + m_SplitterBar->SetSize( 3, Height() ); +} + +void Properties::OnSplitterMoved( Controls::Base * /*control*/ ) +{ + InvalidateChildren(); +} + +int Properties::GetSplitWidth() +{ + return m_SplitterBar->X(); +} + +PropertyRow* Properties::Add( const TextObject& text, const TextObject& value ) +{ + return Add( text, new Property::Text( this ), value ); +} + +PropertyRow* Properties::Add( const TextObject& text, Property::Base* pProp, const TextObject& value ) +{ + PropertyRow* row = new PropertyRow( this ); + row->Dock( Pos::Top ); + row->GetLabel()->SetText( text ); + row->SetProperty( pProp ); + + pProp->SetPropertyValue( value, true ); + + m_SplitterBar->BringToFront(); + return row; +} + +PropertyRow* Properties::Find( const TextObject& text ) +{ + for ( Base::List::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it ) + { + PropertyRow* row = gwen_cast(*it); + if ( !row ) continue; + + if ( row->GetLabel()->GetText() == text ) + return row; + } + + return NULL; +} + +void Properties::Clear() +{ + Base::List ChildListCopy = GetChildren(); + for ( Base::List::iterator it = ChildListCopy.begin(); it != ChildListCopy.end(); ++it ) + { + PropertyRow* row = gwen_cast(*it); + if ( !row ) continue; + + row->DelayedDelete(); + } +} + +class PropertyRowLabel : public Label +{ + GWEN_CONTROL_INLINE ( PropertyRowLabel, Label ) + { + SetAlignment( Pos::Left | Pos::CenterV ); + m_pPropertyRow = NULL; + } + + void UpdateColours() + { + if ( IsDisabled() ) return SetTextColor( GetSkin()->Colors.Button.Disabled ); + if ( m_pPropertyRow && m_pPropertyRow->IsEditing() ) return SetTextColor( GetSkin()->Colors.Properties.Label_Selected ); + if ( m_pPropertyRow && m_pPropertyRow->IsHovered() ) return SetTextColor( GetSkin()->Colors.Properties.Label_Hover ); + + SetTextColor( GetSkin()->Colors.Properties.Label_Normal ); + } + + void SetPropertyRow( PropertyRow * p ){ m_pPropertyRow = p; } + +protected: + + PropertyRow* m_pPropertyRow; +}; + + +GWEN_CONTROL_CONSTRUCTOR( PropertyRow ) +{ + m_Property = NULL; + + PropertyRowLabel* pLabel = new PropertyRowLabel( this ); + pLabel->SetPropertyRow( this ); + pLabel->Dock( Pos::Left ); + pLabel->SetAlignment( Pos::Left | Pos::Top ); + pLabel->SetMargin( Margin( 2, 2, 0, 0 ) ); + m_Label = pLabel; +} + +void PropertyRow::Render( Gwen::Skin::Base* skin ) +{ + /* SORRY */ + if ( IsEditing() != m_bLastEditing ) + { + OnEditingChanged(); + m_bLastEditing = IsEditing(); + } + + if ( IsHovered() != m_bLastHover ) + { + OnHoverChanged(); + m_bLastHover = IsHovered(); + } + /* SORRY */ + + skin->DrawPropertyRow( this, m_Label->Right(), IsEditing(), IsHovered() | m_Property->IsHovered() ); +} + +void PropertyRow::Layout( Gwen::Skin::Base* /*skin*/ ) +{ + Properties* pParent = gwen_cast( GetParent() ); + if ( !pParent ) return; + + m_Label->SetWidth( pParent->GetSplitWidth() ); + + if ( m_Property ) + { + SetHeight( m_Property->Height() ); + } +} + +void PropertyRow::SetProperty( Property::Base* prop ) +{ + m_Property = prop; + m_Property->SetParent( this ); + m_Property->Dock( Pos::Fill ); + m_Property->onChange.Add( this, &ThisClass::OnPropertyValueChanged ); +} + +void PropertyRow::OnPropertyValueChanged( Gwen::Controls::Base* /*control*/ ) +{ + Event::Information info; + info.String = GetProperty()->GetPropertyValue(); + + onChange.Call( this, info ); +} + +void PropertyRow::OnEditingChanged() +{ + m_Label->Redraw(); +} + +void PropertyRow::OnHoverChanged() +{ + m_Label->Redraw(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_properties.h b/lib/gwen/controls/gwen_properties.h new file mode 100644 index 0000000..f0aa80b --- /dev/null +++ b/lib/gwen/controls/gwen_properties.h @@ -0,0 +1,84 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTIES_H +#define GWEN_CONTROLS_PROPERTIES_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "property/gwen_baseproperty.h" +#include "property/gwen_text.h" +#include "gwen_splitterbar.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + + class PropertyRow; + + class GWEN_EXPORT Properties : public Base + { + public: + + GWEN_CONTROL( Properties, Base ); + + virtual void PostLayout( Gwen::Skin::Base* skin ); + + PropertyRow* Add( const TextObject& text, const TextObject& value = "" ); + PropertyRow* Add( const TextObject& text, Property::Base* pProp, const TextObject& value = "" ); + PropertyRow* Find( const TextObject& text ); + + virtual int GetSplitWidth(); + + virtual void Clear(); + + protected: + + virtual void OnSplitterMoved( Controls::Base * control ); + + Controls::SplitterBar* m_SplitterBar; + + }; + + class GWEN_EXPORT PropertyRow : public Base + { + public: + + GWEN_CONTROL( PropertyRow, Base ); + + virtual Label* GetLabel(){ return m_Label; } + virtual void SetProperty( Property::Base* prop ); + virtual Property::Base* GetProperty(){ return m_Property; } + + virtual void Layout( Gwen::Skin::Base* skin ); + virtual void Render( Gwen::Skin::Base* skin ); + + virtual bool IsEditing(){ return m_Property && m_Property->IsEditing(); } + virtual bool IsHovered(){ return BaseClass::IsHovered() || (m_Property && m_Property->IsHovered()); } + virtual void OnEditingChanged(); + virtual void OnHoverChanged(); + + Event::Caller onChange; + + protected: + + void OnPropertyValueChanged( Gwen::Controls::Base* control ); + + Label* m_Label; + Property::Base* m_Property; + + bool m_bLastEditing; + bool m_bLastHover; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_propertytree.cpp b/lib/gwen/controls/gwen_propertytree.cpp new file mode 100644 index 0000000..f6fa8a2 --- /dev/null +++ b/lib/gwen/controls/gwen_propertytree.cpp @@ -0,0 +1,54 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_propertytree.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace Controls + { + + Properties* PropertyTree::Add( const TextObject& text ) + { + TreeNode* node = new PropertyTreeNode( this ); + node->SetText( text ); + node->Dock( Pos::Top ); + + Properties* props = new Properties( node ); + props->Dock( Pos::Top ); + + return props; + } + + Properties* PropertyTree::Find( const TextObject& text ) + { + Controls::Base::List& children = GetChildNodes(); + + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + PropertyTreeNode* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + if ( pChild->GetText() == text ) + { + Base::List& nodechildren = pChild->GetChildren(); + for ( Base::List::iterator iter = nodechildren.begin(); iter != nodechildren.end(); ++iter ) + { + Properties* pPropertyChild = gwen_cast(*iter); + if ( !pPropertyChild ) continue; + + return pPropertyChild; + } + } + } + + return NULL; + } + } +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_propertytree.h b/lib/gwen/controls/gwen_propertytree.h new file mode 100644 index 0000000..d32f839 --- /dev/null +++ b/lib/gwen/controls/gwen_propertytree.h @@ -0,0 +1,54 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTYTREE_H +#define GWEN_CONTROLS_PROPERTYTREE_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_treecontrol.h" +#include "gwen_properties.h" + + +namespace Gwen +{ + namespace Controls + { + class PropertyTreeNode : public TreeNode + { + public: + + GWEN_CONTROL_INLINE( PropertyTreeNode, TreeNode ) + { + m_Title->SetTextColorOverride( GetSkin()->Colors.Properties.Title ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawPropertyTreeNode( this, m_InnerPanel->X(), m_InnerPanel->Y() ); + } + + }; + + class PropertyTree : public TreeControl + { + public: + + GWEN_CONTROL_INLINE( PropertyTree, TreeControl ) + { + + } + + Properties* Add( const TextObject& text ); + Properties* Find( const TextObject& text ); + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_radiobutton.cpp b/lib/gwen/controls/gwen_radiobutton.cpp new file mode 100644 index 0000000..affd8e0 --- /dev/null +++ b/lib/gwen/controls/gwen_radiobutton.cpp @@ -0,0 +1,24 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_radiobutton.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( RadioButton ) +{ + SetSize( 15, 15 ); + SetMouseInputEnabled( true ); + SetTabable( false ); +} + +void RadioButton::Render( Skin::Base* skin ) +{ + skin->DrawRadioButton( this, IsChecked(), IsDepressed() ); +} + diff --git a/lib/gwen/controls/gwen_radiobutton.h b/lib/gwen/controls/gwen_radiobutton.h new file mode 100644 index 0000000..e943569 --- /dev/null +++ b/lib/gwen/controls/gwen_radiobutton.h @@ -0,0 +1,78 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RADIOBUTTON_H +#define GWEN_CONTROLS_RADIOBUTTON_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_checkbox.h" +#include "gwen_labelclickable.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT RadioButton : public CheckBox + { + GWEN_CONTROL( RadioButton, CheckBox ); + virtual void Render( Skin::Base* skin ); + + private: + + // From CheckBox + virtual bool AllowUncheck(){ return false; } + }; + + class GWEN_EXPORT LabeledRadioButton : public Base + { + public: + + GWEN_CONTROL_INLINE( LabeledRadioButton, Base ) + { + SetSize( 200, 19 ); + + m_RadioButton = new RadioButton( this ); + m_RadioButton->Dock( Pos::Left ); + m_RadioButton->SetMargin( Margin( 0, 2, 2, 2 ) ); + m_RadioButton->SetTabable( false ); + m_RadioButton->SetKeyboardInputEnabled( false ); + + m_Label = new LabelClickable( this ); + m_Label->SetAlignment( Pos::CenterV | Pos::Left ); + m_Label->SetText( "Radio Button" ); + m_Label->Dock( Pos::Fill ); + m_Label->onPress.Add( m_RadioButton, &CheckBox::OnPress ); + m_Label->SetTabable( false ); + m_Label->SetKeyboardInputEnabled( false ); + } + + void RenderFocus( Gwen::Skin::Base* skin ) + { + if ( Gwen::KeyboardFocus != this ) return; + if ( !IsTabable() ) return; + + skin->DrawKeyboardHighlight( this, GetRenderBounds(), 0 ); + } + + virtual RadioButton* GetRadioButton() { return m_RadioButton; } + virtual LabelClickable* GetLabel(){ return m_Label; } + virtual bool OnKeySpace(bool bDown) { if ( bDown ) m_RadioButton->SetChecked( !m_RadioButton->IsChecked() ); return true; } + + virtual void Select(){ m_RadioButton->SetChecked( true ); } + + private: + + RadioButton* m_RadioButton; + LabelClickable* m_Label; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_radiobuttoncontroller.cpp b/lib/gwen/controls/gwen_radiobuttoncontroller.cpp new file mode 100644 index 0000000..74d108b --- /dev/null +++ b/lib/gwen/controls/gwen_radiobuttoncontroller.cpp @@ -0,0 +1,69 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_radiobuttoncontroller.h" +#include "gwen_radiobutton.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( RadioButtonController ) +{ + m_Selected = NULL; + SetTabable( false ); + SetKeyboardInputEnabled( false ); +} + +void RadioButtonController::OnRadioClicked( Gwen::Controls::Base* pFromPanel ) +{ + RadioButton* pCheckedRadioButton = gwen_cast( pFromPanel ); + + //Iterate through all other buttons and set them to false; + for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter) + { + Base* pChild = *iter; + LabeledRadioButton* pLRB = gwen_cast(pChild); + if ( pLRB ) + { + RadioButton* pChildRadioButton = pLRB->GetRadioButton(); + if ( pChildRadioButton == pCheckedRadioButton ) + { + m_Selected = pLRB; + } + else + { + pLRB->GetRadioButton()->SetChecked( false ); + } + } + } + + OnChange(); +} + +void RadioButtonController::OnChange() +{ + onSelectionChange.Call( this ); +} + +LabeledRadioButton* RadioButtonController::AddOption( const Gwen::String& strText, const Gwen::String& strOptionName ) +{ + LabeledRadioButton* lrb = new LabeledRadioButton( this ); + + lrb->SetName( strOptionName ); + lrb->GetLabel()->SetText( strText ); + lrb->GetRadioButton()->onChecked.Add( this, &RadioButtonController::OnRadioClicked ); + lrb->Dock( Pos::Top ); + lrb->SetMargin( Margin( 0, 1, 0, 1 ) ); + lrb->SetKeyboardInputEnabled( false ); + lrb->SetTabable( false ); + + Invalidate(); + + return lrb; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_radiobuttoncontroller.h b/lib/gwen/controls/gwen_radiobuttoncontroller.h new file mode 100644 index 0000000..0fcce78 --- /dev/null +++ b/lib/gwen/controls/gwen_radiobuttoncontroller.h @@ -0,0 +1,47 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RADIOBOTTONCONTROLLER_H +#define GWEN_CONTROLS_RADIOBOTTONCONTROLLER_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_radiobutton.h" + + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT RadioButtonController : public Base + { + public: + + GWEN_CONTROL( RadioButtonController, Base ); + + virtual void Render( Skin::Base* /*skin*/ ){}; + virtual void OnRadioClicked( Base* pFromPanel ); + + virtual void OnChange(); + + virtual LabeledRadioButton* AddOption( const Gwen::String& strText, const Gwen::String& strOptionName = "" ); + + virtual LabeledRadioButton* GetSelected(){ return m_Selected; } + + virtual const Gwen::String& GetSelectedName(){ return m_Selected->GetName(); } + virtual const TextObject& GetSelectedLabel(){ return m_Selected->GetLabel()->GetText(); } + + Event::Caller onSelectionChange; + + private: + + LabeledRadioButton* m_Selected; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_rectangle.cpp b/lib/gwen/controls/gwen_rectangle.cpp new file mode 100644 index 0000000..d72d3f7 --- /dev/null +++ b/lib/gwen/controls/gwen_rectangle.cpp @@ -0,0 +1,23 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_rectangle.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( Rectangle ) +{ + m_Color = Gwen::Color( 255, 255, 255, 255 ); +} + +void Rectangle::Render( Skin::Base* skin ) +{ + skin->GetRender()->SetDrawColor( m_Color ); + skin->GetRender()->DrawFilledRect( GetRenderBounds() ); +} diff --git a/lib/gwen/controls/gwen_rectangle.h b/lib/gwen/controls/gwen_rectangle.h new file mode 100644 index 0000000..4ad7e69 --- /dev/null +++ b/lib/gwen/controls/gwen_rectangle.h @@ -0,0 +1,40 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RECTANGLE_H +#define GWEN_CONTROLS_RECTANGLE_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "../gwen.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT Rectangle : public Controls::Base + { + public: + + GWEN_CONTROL( Rectangle, Controls::Base ); + + virtual void Render( Skin::Base* skin ); + + const Gwen::Color& GetColor(){ return m_Color; } + void SetColor( const Gwen::Color& col ){ m_Color = col; } + + protected: + + Gwen::Color m_Color; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_resizablecontrol.cpp b/lib/gwen/controls/gwen_resizablecontrol.cpp new file mode 100644 index 0000000..21ebf05 --- /dev/null +++ b/lib/gwen/controls/gwen_resizablecontrol.cpp @@ -0,0 +1,112 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_imagepanel.h" +#include "gwen_label.h" +#include "gwen_resizablecontrol.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +GWEN_CONTROL_CONSTRUCTOR( ResizableControl ) +{ + m_bResizable = true; + m_MinimumSize = Gwen::Point( 5, 5 ); + m_bClampMovement = false; + + m_Resizer[5] = NULL; + m_Resizer[0] = NULL; + + m_Resizer[2] = new Resizer (this ); + m_Resizer[2]->Dock( Pos::Bottom ); + m_Resizer[2]->SetResizeDir( Pos::Bottom ); + m_Resizer[2]->SetTarget( this ); + m_Resizer[2]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[1] = new Resizer( m_Resizer[2] ); + m_Resizer[1]->Dock( Pos::Left ); + m_Resizer[1]->SetResizeDir( Pos::Bottom | Pos::Left ); + m_Resizer[1]->SetTarget(this ); + m_Resizer[1]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[3] = new Resizer( m_Resizer[2] ); + m_Resizer[3]->Dock( Pos::Right); + m_Resizer[3]->SetResizeDir( Pos::Bottom | Pos::Right ); + m_Resizer[3]->SetTarget( this ); + m_Resizer[3]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[8] = new Resizer( this ); + m_Resizer[8]->Dock( Pos::Top ); + m_Resizer[8]->SetResizeDir( Pos::Top ); + m_Resizer[8]->SetTarget( this ); + m_Resizer[8]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[7] = new Resizer( m_Resizer[8] ); + m_Resizer[7]->Dock( Pos::Left ); + m_Resizer[7]->SetResizeDir( Pos::Top | Pos::Left ); + m_Resizer[7]->SetTarget( this ); + m_Resizer[7]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[9] = new Resizer( m_Resizer[8] ); + m_Resizer[9]->Dock( Pos::Right ); + m_Resizer[9]->SetResizeDir( Pos::Top| Pos::Right ); + m_Resizer[9]->SetTarget( this ); + m_Resizer[9]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[4] = new Resizer( this ); + m_Resizer[4]->Dock( Pos::Left ); + m_Resizer[4]->SetResizeDir( Pos::Left ); + m_Resizer[4]->SetTarget( this ); + m_Resizer[4]->onResize.Add( this, &ResizableControl::OnResizedInternal ); + + m_Resizer[6] = new Resizer( this ); + m_Resizer[6]->Dock( Pos::Right ); + m_Resizer[6]->SetResizeDir( Pos::Right ); + m_Resizer[6]->SetTarget( this ); + m_Resizer[6]->onResize.Add( this, &ResizableControl::OnResizedInternal ); +} + +void ResizableControl::DisableResizing() +{ + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + Resizer* resizer = gwen_cast(*it); + if ( !resizer ) continue; + + resizer->SetMouseInputEnabled( false ); + resizer->SetHidden( false ); + SetPadding( Padding( resizer->Width(), resizer->Width(), resizer->Width(), resizer->Width() ) ); + } +} + +bool ResizableControl::SetBounds( int x, int y, int w, int h ) +{ + Gwen::Point minSize = GetMinimumSize(); + + // Clamp Minimum Size + if ( w < minSize.x ) w = minSize.x; + if ( h < minSize.y ) h = minSize.y; + + // Clamp to parent's window + Base* pParent = GetParent(); + if ( pParent && m_bClampMovement ) + { + if ( x + w > pParent->Width() ) x = pParent->Width() - w; + if ( x < 0 ) x = 0; + if ( y + h > pParent->Height() ) y = pParent->Height() - h; + if ( y < 0 ) y = 0; + } + + return BaseClass::SetBounds( x, y, w, h ); +} + +void ResizableControl::OnResizedInternal( Controls::Base* /*pControl*/ ) +{ + onResize.Call( this ); + OnResized(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_resizablecontrol.h b/lib/gwen/controls/gwen_resizablecontrol.h new file mode 100644 index 0000000..071d8dd --- /dev/null +++ b/lib/gwen/controls/gwen_resizablecontrol.h @@ -0,0 +1,61 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RESIZABLECONTROL_H +#define GWEN_CONTROLS_RESIZABLECONTROL_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_button.h" +#include "gwen_dragger.h" +#include "gwen_label.h" +#include "gwen_resizer.h" +#include "../gwen.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT ResizableControl : public Base + { + public: + + GWEN_CONTROL( ResizableControl, Base ); + + virtual void SetClampMovement( bool shouldClamp ) { m_bClampMovement = shouldClamp; } + virtual bool GetClampMovement() { return m_bClampMovement; } + + virtual void SetMinimumSize( const Gwen::Point& minSize ) { m_MinimumSize = minSize; } + virtual Gwen::Point GetMinimumSize() { return m_MinimumSize; } + + virtual void DisableResizing(); + + virtual bool SetBounds( int x, int y, int w, int h ); + + virtual void OnResized(){}; + + Event::Caller onResize; + + virtual ControlsInternal::Resizer* GetResizer( int iResizer ){ return m_Resizer[iResizer]; } + + protected: + + void OnResizedInternal( Controls::Base* pControl ); + + Gwen::Point m_MinimumSize; + bool m_bClampMovement; + bool m_bResizable; + + ControlsInternal::Resizer* m_Resizer[10]; + + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_resizer.cpp b/lib/gwen/controls/gwen_resizer.cpp new file mode 100644 index 0000000..7caa188 --- /dev/null +++ b/lib/gwen/controls/gwen_resizer.cpp @@ -0,0 +1,120 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_resizer.h" + +using namespace Gwen; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( Resizer ) +{ + m_iResizeDir = Pos::Left; + SetMouseInputEnabled( true ); + SetSize( 6, 6 ); +} + +void Resizer::OnMouseMoved( int x, int y, int /*deltaX*/, int /*deltaY*/ ) +{ + if ( !m_pTarget ) return; + if ( !m_bDepressed ) return; + + //Gwen::Rect oldBounds = m_pTarget->GetBounds(); + Gwen::Rect pBounds = m_pTarget->GetBounds(); + + Gwen::Point pntMin = m_pTarget->GetMinimumSize(); + + Gwen::Point pCursorPos = m_pTarget->CanvasPosToLocal( Gwen::Point( x, y ) ); + + Gwen::Point pDelta = m_pTarget->LocalPosToCanvas( m_HoldPos ); + pDelta.x -= x; + pDelta.y -= y; + + if ( m_iResizeDir & Pos::Left ) + { + pBounds.x -= pDelta.x; + pBounds.w += pDelta.x; + + // Conform to minimum size here so we don't + // go all weird when we snap it in the base conrt + + if ( pBounds.w < pntMin.x ) + { + int diff = pntMin.x - pBounds.w; + pBounds.w += diff; + pBounds.x -= diff; + } + + } + + if ( m_iResizeDir & Pos::Top ) + { + pBounds.y -= pDelta.y; + pBounds.h += pDelta.y; + + // Conform to minimum size here so we don't + // go all weird when we snap it in the base conrt + + if ( pBounds.h < pntMin.y ) + { + int diff = pntMin.y - pBounds.h; + pBounds.h += diff; + pBounds.y -= diff; + } + + } + + if ( m_iResizeDir & Pos::Right ) + { + // This is complicated. + // Basically we want to use the HoldPos, so it doesn't snap to the edge of the control + // But we need to move the HoldPos with the window movement. Yikes. + // I actually think this might be a big hack around the way this control works with regards + // to the holdpos being on the parent panel. + + int woff = pBounds.w - m_HoldPos.x; + int diff = pBounds.w; + pBounds.w = pCursorPos.x + woff; + if ( pBounds.w < pntMin.x ) pBounds.w = pntMin.x; + diff -= pBounds.w; + + m_HoldPos.x -= diff; + } + + if ( m_iResizeDir & Pos::Bottom ) + { + int hoff = pBounds.h - m_HoldPos.y; + int diff = pBounds.h; + pBounds.h = pCursorPos.y + hoff; + if ( pBounds.h < pntMin.y ) pBounds.h = pntMin.y; + diff -= pBounds.h; + + m_HoldPos.y -= diff; + } + + m_pTarget->SetBounds( pBounds ); + + onResize.Call( this ); +} + +void Resizer::SetResizeDir( int dir ) +{ + m_iResizeDir = dir; + + if ( (dir & Pos::Left && dir & Pos::Top) || (dir & Pos::Right && dir & Pos::Bottom) ) + return SetCursor( Gwen::CursorType::SizeNWSE ); + + if ( (dir & Pos::Right && dir & Pos::Top) || (dir & Pos::Left && dir & Pos::Bottom) ) + return SetCursor( Gwen::CursorType::SizeNESW ); + + if ( dir & Pos::Right || dir & Pos::Left ) + return SetCursor( Gwen::CursorType::SizeWE ); + + if ( dir & Pos::Top || dir & Pos::Bottom ) + return SetCursor( Gwen::CursorType::SizeNS ); + +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_resizer.h b/lib/gwen/controls/gwen_resizer.h new file mode 100644 index 0000000..56199e5 --- /dev/null +++ b/lib/gwen/controls/gwen_resizer.h @@ -0,0 +1,39 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RESIZER_H +#define GWEN_CONTROLS_RESIZER_H + +#include "gwen_base.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_dragger.h" + + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT Resizer : public Dragger + { + public: + + GWEN_CONTROL( Resizer, Dragger ); + + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual void SetResizeDir( int dir ); + + Event::Caller onResize; + + protected: + + int m_iResizeDir; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_richlabel.cpp b/lib/gwen/controls/gwen_richlabel.cpp new file mode 100644 index 0000000..668a1ed --- /dev/null +++ b/lib/gwen/controls/gwen_richlabel.cpp @@ -0,0 +1,209 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_richlabel.h" +#include "gwen_label.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +const unsigned char Type_Text = 0; +const unsigned char Type_Newline = 1; + +GWEN_CONTROL_CONSTRUCTOR( RichLabel ) +{ + m_bNeedsRebuild = false; +} + +void RichLabel::AddLineBreak() +{ + DividedText t; + t.type = Type_Newline; + + m_TextBlocks.push_back( t ); +} + +void RichLabel::AddText( const Gwen::TextObject& text, Gwen::Color color, Gwen::Font* font ) +{ + if ( text.length() == 0 ) return; + + Gwen::Utility::Strings::List lst; + Gwen::Utility::Strings::Split( text.Get(), "\n", lst, false ); + + for (size_t i=0; i 0 ) AddLineBreak(); + + DividedText t; + t.type = Type_Text; + t.text = lst[i]; + t.color = color; + t.font = font; + + m_TextBlocks.push_back( t ); + m_bNeedsRebuild = true; + Invalidate(); + } +} + +bool RichLabel::SizeToChildren( bool w, bool h ) +{ + Rebuild(); + return BaseClass::SizeToChildren( w, h ); +} + +void RichLabel::SplitLabel( const Gwen::String& text, Gwen::Font* pFont, const DividedText& txt, int& x, int& y, int& lineheight ) +{ + Gwen::Utility::Strings::List lst; + Gwen::Utility::Strings::Split( text, " ", lst, true ); + if ( lst.size() == 0 ) return; + + int iSpaceLeft = Width() - x; + + // Does the whole word fit in? + { + Gwen::Point StringSize = GetSkin()->GetRender()->MeasureText( pFont, text ); + if ( iSpaceLeft > StringSize.x ) + { + return CreateLabel( text, txt, x, y, lineheight, true ); + } + } + + // If the first word is bigger than the line, just give up. + { + Gwen::Point WordSize = GetSkin()->GetRender()->MeasureText( pFont, lst[0] ); + if ( WordSize.x >= iSpaceLeft ) + { + CreateLabel( lst[0], txt, x, y, lineheight, true ); + if ( lst[0].size() >= text.size() ) return; + + Gwen::String LeftOver = text.substr( lst[0].size() + 1 ); + return SplitLabel( LeftOver, pFont, txt, x, y, lineheight ); + } + } + + Gwen::String strNewString = ""; + for ( size_t i=0; iGetRender()->MeasureText( pFont, strNewString + lst[i] ); + if ( WordSize.x > iSpaceLeft ) + { + CreateLabel( strNewString, txt, x, y, lineheight, true ); + x = 0; + y += lineheight; + break;; + } + + strNewString += lst[i]; + } + + Gwen::String LeftOver = text.substr( strNewString.size() + 1 ); + return SplitLabel( LeftOver, pFont, txt, x, y, lineheight ); +} + +void RichLabel::CreateLabel( const Gwen::String& text, const DividedText& txt, int& x, int& y, int& lineheight, bool NoSplit ) +{ + + // + // Use default font or is one set? + // + Gwen::Font* pFont = GetSkin()->GetDefaultFont(); + if ( txt.font ) pFont = txt.font; + + // + // This string is too long for us, split it up. + // + Gwen::Point p = GetSkin()->GetRender()->MeasureText( pFont, text ); + + if ( lineheight == -1 ) + { + lineheight = p.y; + } + + if ( !NoSplit ) + { + if ( x + p.x > Width() ) + { + return SplitLabel( text, pFont, txt, x, y, lineheight ); + } + } + + // + // Wrap + // + if ( x + p.x >= Width() ) + { + CreateNewline( x, y, lineheight ); + } + + Gwen::Controls::Label* pLabel = new Gwen::Controls::Label( this ); + pLabel->SetText( x == 0 ? Gwen::Utility::Strings::TrimLeft( text, " " ) : text ); + pLabel->SetTextColor( txt.color ); + pLabel->SetFont( pFont ); + pLabel->SizeToContents(); + pLabel->SetPos( x, y ); + + //lineheight = (lineheight + pLabel->Height()) / 2; + + x += pLabel->Width(); + + if ( x >= Width() ) + { + CreateNewline( x, y, lineheight ); + } +} + +void RichLabel::CreateNewline( int& x, int& y, int& lineheight ) +{ + x = 0; + y += lineheight; +} + +void RichLabel::Rebuild() +{ + RemoveAllChildren(); + + int x = 0; + int y = 0; + int lineheight = -1; + for ( DividedText::List::iterator it = m_TextBlocks.begin(); it != m_TextBlocks.end(); ++it ) + { + if ( it->type == Type_Newline ) + { + CreateNewline( x, y, lineheight ); + continue; + } + + if ( it->type == Type_Text ) + { + CreateLabel( (*it).text, *it, x, y, lineheight, false ); + continue; + } + + } + + m_bNeedsRebuild = false; +} + +void RichLabel::OnBoundsChanged( Gwen::Rect oldBounds ) +{ + BaseClass::OnBoundsChanged( oldBounds ); + + Rebuild(); +} + +void RichLabel::Layout( Gwen::Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + if ( m_bNeedsRebuild ) + { + Rebuild(); + } +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_richlabel.h b/lib/gwen/controls/gwen_richlabel.h new file mode 100644 index 0000000..8e28952 --- /dev/null +++ b/lib/gwen/controls/gwen_richlabel.h @@ -0,0 +1,61 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_RICHLABEL_H +#define GWEN_CONTROLS_RICHLABEL_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_text.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT RichLabel : public Controls::Base + { + public: + + GWEN_CONTROL( RichLabel, Gwen::Controls::Base ); + + void AddLineBreak(); + void AddText( const Gwen::TextObject& text, Gwen::Color color, Gwen::Font* font = NULL ); + + virtual bool SizeToChildren( bool w = true, bool h = true ); + + protected: + + struct DividedText + { + typedef stl::list List; + DividedText() + { + type = 0; + font = NULL; + } + + unsigned char type; + Gwen::String text; + Gwen::Color color; + Gwen::Font* font; + }; + + void Layout( Gwen::Skin::Base* skin ); + void SplitLabel( const Gwen::String& text, Gwen::Font* pFont, const DividedText& txt, int& x, int& y, int& lineheight ); + void CreateNewline( int& x, int& y, int& lineheight ); + void CreateLabel( const Gwen::String& text, const DividedText& txt, int& x, int& y, int& lineheight, bool NoSplit ); + void Rebuild(); + + void OnBoundsChanged( Gwen::Rect oldBounds ); + + DividedText::List m_TextBlocks; + bool m_bNeedsRebuild; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_scrollbar.cpp b/lib/gwen/controls/gwen_scrollbar.cpp new file mode 100644 index 0000000..47a427b --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbar.cpp @@ -0,0 +1,83 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollbar.h" +#include "gwen_scrollbarbutton.h" +#include "gwen_scrollbarbar.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( BaseScrollBar ) +{ + for (int i = 0; i < 2; i++) + { + m_ScrollButton[i] = new ScrollBarButton( this ); + } + + m_Bar = new ScrollBarBar( this ); + + SetBounds( 0, 0, 15, 15 ); + m_bDepressed = false; + + m_fScrolledAmount = 0; + m_fContentSize = 0; + m_fViewableContentSize = 0; + + SetNudgeAmount( 20 ); +} + +void BaseScrollBar::Render( Skin::Base* skin ) +{ + skin->DrawScrollBar( this, IsHorizontal(), m_bDepressed ); +} + +void BaseScrollBar::OnBarMoved( Controls::Base* /*control*/ ) +{ + onBarMoved.Call( this ); +} + +void BaseScrollBar::BarMovedNotification() +{ + OnBarMoved( this ); +} + +void BaseScrollBar::SetContentSize( float size ) +{ + if ( m_fContentSize != size ) + { + Invalidate(); + } + + m_fContentSize = size; + +} +void BaseScrollBar::SetViewableContentSize( float size ) +{ + if ( m_fViewableContentSize != size ) + Invalidate(); + + m_fViewableContentSize = size; +} + +bool BaseScrollBar::SetScrolledAmount( float amount, bool forceUpdate ) +{ + if ( m_fScrolledAmount == amount && !forceUpdate ) return false; + + m_fScrolledAmount = amount; + Invalidate(); + BarMovedNotification(); + return true; +} + + + + + + diff --git a/lib/gwen/controls/gwen_scrollbar.h b/lib/gwen/controls/gwen_scrollbar.h new file mode 100644 index 0000000..3c604ce --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbar.h @@ -0,0 +1,79 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SCROLLBAR_H +#define GWEN_CONTROLS_SCROLLBAR_H + +#include "gwen_base.h" +#include "gwen_scrollbarbar.h" +#include "gwen_scrollbarbutton.h" +#include "../gwen.h" + + +#define SCROLL_BUTTON_UP 0 +#define SCROLL_BUTTON_LEFT 0 +#define SCROLL_BUTTON_DOWN 1 +#define SCROLL_BUTTON_RIGHT 1 +#define NUDGE_DIST 10 + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT BaseScrollBar : public Base + { + public: + + GWEN_CONTROL( BaseScrollBar, Base ); + + virtual void Render( Skin::Base* skin ); + + virtual void SetBarSize(int size) = 0; + virtual int GetBarSize() = 0; + virtual int GetBarPos() = 0; + + virtual void OnBarMoved( Controls::Base* control); + virtual void OnMouseClickLeft( int /*x*/, int /*y*/, bool /*bDown*/ ){} + + virtual void ScrollToLeft(){} + virtual void ScrollToRight(){} + virtual void ScrollToTop(){} + virtual void ScrollToBottom(){} + + virtual float GetNudgeAmount() { return m_fNudgeAmount / m_fContentSize; } + virtual void SetNudgeAmount( float nudge ) { m_fNudgeAmount = nudge; } + + virtual void BarMovedNotification(); + + virtual float CalculateScrolledAmount() { return 0; } + virtual int CalculateBarSize() { return 0; } + virtual bool SetScrolledAmount(float amount, bool forceUpdate); + + virtual void SetContentSize(float size); + virtual void SetViewableContentSize(float size); + + virtual int GetButtonSize() { return 0; } + virtual float GetScrolledAmount() { return m_fScrolledAmount; } + + virtual bool IsHorizontal(){ return false; } + + Gwen::Event::Caller onBarMoved; + + protected: + + ControlsInternal::ScrollBarButton* m_ScrollButton[2]; + ControlsInternal::ScrollBarBar * m_Bar; + + bool m_bDepressed; + float m_fScrolledAmount; + float m_fContentSize; + float m_fViewableContentSize; + float m_fNudgeAmount; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_scrollbarbar.cpp b/lib/gwen/controls/gwen_scrollbarbar.cpp new file mode 100644 index 0000000..2c5407a --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbarbar.cpp @@ -0,0 +1,57 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollbar.h" +#include "gwen_scrollbarbar.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +//Actual bar representing height of parent + +GWEN_CONTROL_CONSTRUCTOR( ScrollBarBar ) +{ + RestrictToParent( true ); + SetTarget( this ); +} + +void ScrollBarBar::Render( Skin::Base* skin ) +{ + skin->DrawScrollBarBar(this, m_bDepressed, IsHovered(), m_bHorizontal ); + BaseClass::Render( skin ); +} + +void ScrollBarBar::OnMouseMoved( int x, int y, int deltaX, int deltaY ) +{ + BaseClass::OnMouseMoved( x, y, deltaX, deltaY ); + + if ( !m_bDepressed ) + return; + + InvalidateParent(); +} + +void ScrollBarBar::OnMouseClickLeft( int x, int y, bool bDown ) +{ + BaseClass::OnMouseClickLeft( x, y, bDown ); + InvalidateParent(); +} + +void ScrollBarBar::Layout( Skin::Base* /*skin*/ ) +{ + if ( !GetParent() ) + return; + + //Move to our current position to force clamping - is this a hack? + MoveTo( X(), Y() ); +} + +void ScrollBarBar::MoveTo( int x, int y ) +{ + BaseClass::MoveTo( x, y ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_scrollbarbar.h b/lib/gwen/controls/gwen_scrollbarbar.h new file mode 100644 index 0000000..3ebdd29 --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbarbar.h @@ -0,0 +1,46 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SCROLLBARBAR_H +#define GWEN_CONTROLS_SCROLLBARBAR_H + +#include "gwen_dragger.h" +#include "../gwen.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT ScrollBarBar : public ControlsInternal::Dragger + { + public: + + GWEN_CONTROL( ScrollBarBar, ControlsInternal::Dragger ); + + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + + virtual void MoveTo(int x, int y); + + virtual void SetHorizontal() { m_bHorizontal = true; } + virtual void SetVertical() { m_bHorizontal = false; } + virtual bool IsVertical() { return !m_bHorizontal; } + virtual bool IsHorizontal() { return m_bHorizontal; } + virtual bool IsDepressed() { return m_bDepressed; } + + protected: + + bool m_bHorizontal; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_scrollbarbutton.cpp b/lib/gwen/controls/gwen_scrollbarbutton.cpp new file mode 100644 index 0000000..b4158db --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbarbutton.cpp @@ -0,0 +1,44 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollbar.h" +#include "gwen_scrollbarbutton.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( ScrollBarButton ) +{ + SetDirectionUp(); +} + +void ScrollBarButton::SetDirectionUp() +{ + m_iDirection = Pos::Top; +} + +void ScrollBarButton::SetDirectionDown() +{ + m_iDirection = Pos::Bottom; +} + +void ScrollBarButton::SetDirectionLeft() +{ + m_iDirection = Pos::Left; +} + +void ScrollBarButton::SetDirectionRight() +{ + m_iDirection = Pos::Right; +} + +void ScrollBarButton::Render( Skin::Base* skin ) +{ + skin->DrawScrollButton( this, m_iDirection, m_bDepressed, IsHovered(), IsDisabled() ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_scrollbarbutton.h b/lib/gwen/controls/gwen_scrollbarbutton.h new file mode 100644 index 0000000..f59a2bf --- /dev/null +++ b/lib/gwen/controls/gwen_scrollbarbutton.h @@ -0,0 +1,36 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SCROLLBARBOTTON_H +#define GWEN_CONTROLS_SCROLLBARBOTTON_H + +#include "gwen_button.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT ScrollBarButton : public Controls::Button + { + public: + + GWEN_CONTROL( ScrollBarButton, Controls::Button ); + + void Render( Skin::Base* skin ); + + void SetDirectionUp(); + void SetDirectionDown(); + void SetDirectionLeft(); + void SetDirectionRight(); + + protected: + + int m_iDirection; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_scrollcontrol.cpp b/lib/gwen/controls/gwen_scrollcontrol.cpp new file mode 100644 index 0000000..f5bd3d8 --- /dev/null +++ b/lib/gwen/controls/gwen_scrollcontrol.cpp @@ -0,0 +1,275 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollcontrol.h" +#include "gwen_scrollbar.h" +#include "gwen_verticalscrollbar.h" +#include "gwen_horizontalscrollbar.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +GWEN_CONTROL_CONSTRUCTOR( ScrollControl ) +{ + SetMouseInputEnabled( false ); + + m_VerticalScrollBar = new VerticalScrollBar( this ); + m_VerticalScrollBar->Dock( Pos::Right ); + m_VerticalScrollBar->onBarMoved.Add( this, &ScrollControl::VBarMoved ); + m_VerticalScrollBar->SetNudgeAmount( 30 ); + m_bCanScrollV = true; + + m_HorizontalScrollBar = new HorizontalScrollBar( this ); + m_HorizontalScrollBar->Dock( Pos::Bottom ); + m_HorizontalScrollBar->onBarMoved.Add( this, &ScrollControl::HBarMoved ); + m_bCanScrollH = true; + m_HorizontalScrollBar->SetNudgeAmount( 30 ); + + m_InnerPanel = new Base( this ); + m_InnerPanel->SetPos(0, 0); + m_InnerPanel->SetMargin( Margin(5,5,5,5)); + m_InnerPanel->SendToBack(); + m_InnerPanel->SetMouseInputEnabled( false ); + + m_bAutoHideBars = true; +} + +void ScrollControl::SetScroll( bool h, bool v ) +{ + m_bCanScrollV = v; + m_bCanScrollH = h; + m_VerticalScrollBar->SetHidden( !m_bCanScrollV ); + m_HorizontalScrollBar->SetHidden( !m_bCanScrollH ); +} + +void ScrollControl::SetInnerSize( int w, int h ) +{ + m_InnerPanel->SetSize( w, h ); +} + +void ScrollControl::VBarMoved( Controls::Base * /*control*/ ) +{ + Invalidate(); +} + +void ScrollControl::HBarMoved( Controls::Base * /*control*/ ) +{ + Invalidate(); +} + +void ScrollControl::OnChildBoundsChanged( Gwen::Rect /*oldChildBounds*/, Base* /*pChild*/ ) +{ + UpdateScrollBars(); + Invalidate(); +} + +void ScrollControl::Layout( Skin::Base* skin ) +{ + UpdateScrollBars(); + BaseClass::Layout(skin); +} + +bool ScrollControl::OnMouseWheeled( int iDelta ) +{ + if ( CanScrollV() && m_VerticalScrollBar->Visible() ) + { + if ( m_VerticalScrollBar->SetScrolledAmount( m_VerticalScrollBar->GetScrolledAmount() - m_VerticalScrollBar->GetNudgeAmount() * ( (float)iDelta / 60.0f ), true) ) + return true; + } + + if ( CanScrollH() && m_HorizontalScrollBar->Visible() ) + { + if ( m_HorizontalScrollBar->SetScrolledAmount( m_HorizontalScrollBar->GetScrolledAmount() - m_HorizontalScrollBar->GetNudgeAmount() * ( (float)iDelta / 60.0f ), true) ) + return true; + } + + return false; +} +void ScrollControl::Render( Skin::Base* skin ) +{ + +#if 0 + + // Debug render - this shouldn't render ANYTHING REALLY - it should be up to the parent! + + Gwen::Rect rect = GetRenderBounds(); + Gwen::Renderer::Base* render = skin->GetRender(); + + render->SetDrawColor( Gwen::Color( 255, 255, 0, 100 ) ); + render->DrawFilledRect( rect ); + + render->SetDrawColor( Gwen::Color( 255, 0, 0, 100 ) ); + render->DrawFilledRect( m_InnerPanel->GetBounds() ); + + render->RenderText( skin->GetDefaultFont(), Gwen::Point( 0, 0 ), Utility::Format( "Offset: %i %i", m_InnerPanel->X(), m_InnerPanel->Y() ) ); + +#else //0 + + (void)skin; + +#endif //0 +} + +bool ScrollControl::ContentsAreDocked() +{ + if ( !m_InnerPanel ) + return false; + + for ( Base::List::iterator iter = m_InnerPanel->Children.begin(); iter != m_InnerPanel->Children.end(); ++iter ) + { + Base* pChild = *iter; + + if ( pChild->GetDock() == Pos::None ) + return false; + } + + return true; +} + +void ScrollControl::UpdateScrollBars() +{ + if ( !m_InnerPanel ) + return; + + if ( ContentsAreDocked() ) + { + m_VerticalScrollBar->SetHidden( true ); + m_HorizontalScrollBar->SetHidden( true ); + m_InnerPanel->SetSize( GetSize() ); + m_InnerPanel->SetPos( 0, 0 ); + return; + } + + int childrenWidth = 0; + int childrenHeight = 0; + + //Get the max size of all our children together + for ( Base::List::iterator iter = m_InnerPanel->Children.begin(); iter != m_InnerPanel->Children.end(); ++iter ) + { + Base* pChild = *iter; + + childrenWidth = Utility::Max( childrenWidth, pChild->Right() ); + childrenHeight = Utility::Max( childrenHeight, pChild->Bottom() ); + } + + if ( m_bCanScrollH ) + { + m_InnerPanel->SetSize( Utility::Max( Width(), childrenWidth), Utility::Max( Height(), childrenHeight ) ); + } + else + { + m_InnerPanel->SetSize( Width() - (m_VerticalScrollBar->Hidden() ? 0 : m_VerticalScrollBar->Width()-1), Utility::Max( Height(), childrenHeight ) ); + } + + float wPercent = (float)Width() / (float)(childrenWidth + (m_VerticalScrollBar->Hidden() ? 0 : m_VerticalScrollBar->Width())); + float hPercent = (float)Height() / (float)(childrenHeight + (m_HorizontalScrollBar->Hidden() ? 0 : m_HorizontalScrollBar->Height())); + + if ( m_bCanScrollV ) + SetVScrollRequired( hPercent >= 1 ); + else + m_VerticalScrollBar->SetHidden( true ); + + if ( m_bCanScrollH ) + SetHScrollRequired( wPercent >= 1 ); + else + m_HorizontalScrollBar->SetHidden( true ); + + + m_VerticalScrollBar->SetContentSize( m_InnerPanel->Height() ); + m_VerticalScrollBar->SetViewableContentSize( Height() - (m_HorizontalScrollBar->Hidden() ? 0 : m_HorizontalScrollBar->Height())); + + + m_HorizontalScrollBar->SetContentSize( m_InnerPanel->Width() ); + m_HorizontalScrollBar->SetViewableContentSize( Width() - (m_VerticalScrollBar->Hidden() ? 0 : m_VerticalScrollBar->Width()) ); + + int newInnerPanelPosX = 0; + int newInnerPanelPosY = 0; + + if ( CanScrollV() && !m_VerticalScrollBar->Hidden() ) + { + newInnerPanelPosY = -( ( m_InnerPanel->Height() ) - Height() + (m_HorizontalScrollBar->Hidden() ? 0 : m_HorizontalScrollBar->Height()) ) * m_VerticalScrollBar->GetScrolledAmount(); + } + if ( CanScrollH() && !m_HorizontalScrollBar->Hidden() ) + { + newInnerPanelPosX = - ( ( m_InnerPanel->Width() ) - Width() + (m_VerticalScrollBar->Hidden() ? 0 : m_VerticalScrollBar->Width())) * m_HorizontalScrollBar->GetScrolledAmount(); + } + + m_InnerPanel->SetPos( newInnerPanelPosX , newInnerPanelPosY ); +} + +void ScrollControl::SetVScrollRequired(bool req) +{ + if ( req ) + { + m_VerticalScrollBar->SetScrolledAmount( 0, true ); + m_VerticalScrollBar->SetDisabled( true ); + + if ( m_bAutoHideBars ) + m_VerticalScrollBar->SetHidden( true ); + } + else + { + m_VerticalScrollBar->SetHidden( false ); + m_VerticalScrollBar->SetDisabled( false ); + } +} + +void ScrollControl::SetHScrollRequired(bool req) +{ + if ( req ) + { + m_HorizontalScrollBar->SetScrolledAmount( 0, true ); + m_HorizontalScrollBar->SetDisabled( true ); + if ( m_bAutoHideBars ) + m_HorizontalScrollBar->SetHidden( true ); + } + else + { + m_HorizontalScrollBar->SetHidden( false ); + m_HorizontalScrollBar->SetDisabled( true ); + } +} + +void ScrollControl::ScrollToBottom() +{ + if ( !CanScrollV() ) return; + + UpdateScrollBars(); + m_VerticalScrollBar->ScrollToBottom(); + +} +void ScrollControl::ScrollToTop() +{ + if ( CanScrollV() ) + { + UpdateScrollBars(); + m_VerticalScrollBar->ScrollToTop(); + } +} +void ScrollControl::ScrollToLeft() +{ + if ( CanScrollH() ) + { + UpdateScrollBars(); + m_HorizontalScrollBar->ScrollToLeft(); + } +} +void ScrollControl::ScrollToRight() +{ + if ( CanScrollH() ) + { + UpdateScrollBars(); + m_HorizontalScrollBar->ScrollToRight(); + } +} + +void ScrollControl::Clear() +{ + m_InnerPanel->RemoveAllChildren(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_scrollcontrol.h b/lib/gwen/controls/gwen_scrollcontrol.h new file mode 100644 index 0000000..c9c8b5a --- /dev/null +++ b/lib/gwen/controls/gwen_scrollcontrol.h @@ -0,0 +1,71 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SCROLLCONTROL_H +#define GWEN_CONTROLS_SCROLLCONTROL_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_scrollbar.h" +#include "gwen_verticalscrollbar.h" +#include "gwen_horizontalscrollbar.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT ScrollControl : public Base + { + public: + + GWEN_CONTROL( ScrollControl, Base ); + + virtual void Layout( Skin::Base* skin ); + virtual void Render( Skin::Base* skin ); + + virtual void SetScroll( bool h, bool v ); + virtual void SetAutoHideBars(bool should) { m_bAutoHideBars = should; } + virtual bool CanScrollH() { return m_bCanScrollH; } + virtual bool CanScrollV() { return m_bCanScrollV; } + virtual void OnChildBoundsChanged( Gwen::Rect oldChildBounds, Base* pChild ); + virtual void UpdateScrollBars(); + + virtual void SetVScrollRequired(bool req); + virtual void SetHScrollRequired(bool req); + + virtual void SetInnerSize( int w, int h ); + + virtual void VBarMoved(Controls::Base * control); + virtual void HBarMoved(Controls::Base * control); + + virtual bool OnMouseWheeled( int iDelta ); + + virtual void ScrollToBottom(); + virtual void ScrollToTop(); + virtual void ScrollToLeft(); + virtual void ScrollToRight(); + + virtual void Clear(); + + protected: + + virtual bool ContentsAreDocked(); + + bool m_bCanScrollH; + bool m_bCanScrollV; + + bool m_bAutoHideBars; + + Controls::BaseScrollBar* m_VerticalScrollBar; + Controls::BaseScrollBar* m_HorizontalScrollBar; + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_slider.cpp b/lib/gwen/controls/gwen_slider.cpp new file mode 100644 index 0000000..b8eb8c4 --- /dev/null +++ b/lib/gwen/controls/gwen_slider.cpp @@ -0,0 +1,104 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include +#include "gwen_slider.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + +GWEN_CONTROL_CONSTRUCTOR( SliderBar ) +{ + SetTarget( this ); + RestrictToParent( true ); +} + +void SliderBar::Render( Skin::Base* skin ) +{ + skin->DrawSlideButton( this, IsDepressed(), IsHorizontal() ); +} + + +GWEN_CONTROL_CONSTRUCTOR( Slider ) +{ + SetBounds( Gwen::Rect( 0, 0, 32, 128) ); + + m_SliderBar = new SliderBar( this ); + m_SliderBar->onDragged.Add( this, &Slider::OnMoved ); + + m_fMin = 0.0f; + m_fMax = 1.0f; + + m_bClampToNotches = false; + m_iNumNotches = 5; + m_fValue = 0.0f; + + SetTabable( true ); + +} + +void Slider::OnMoved( Controls::Base * /*control*/ ) +{ + SetValueInternal( CalculateValue() ); +} + +void Slider::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); +} + +float Slider::CalculateValue() +{ + return 0; +} + +void Slider::SetFloatValue( float val, bool /*forceUpdate*/ ) +{ + if (val < m_fMin) val = m_fMin; + if (val > m_fMax) val = m_fMax; + // Normalize Value + val = (val - m_fMin) / (m_fMax - m_fMin); + SetValueInternal( val ); + Redraw(); +} + +void Slider::SetValueInternal( float val ) +{ + if ( m_bClampToNotches ) + { + val = floor( (val * (float)m_iNumNotches) + 0.5f ); + val /= (float) m_iNumNotches; + } + + if ( m_fValue != val ) + { + m_fValue = val; + onValueChanged.Call( this ); + } + + UpdateBarFromValue(); +} + +float Slider::GetFloatValue() +{ + return m_fMin + (m_fValue * (m_fMax - m_fMin)); +} + +void Slider::SetRange( float fMin, float fMax ) +{ + m_fMin = fMin; + m_fMax = fMax; +} + +void Slider::RenderFocus( Gwen::Skin::Base* skin ) +{ + if ( Gwen::KeyboardFocus != this ) return; + if ( !IsTabable() ) return; + + skin->DrawKeyboardHighlight( this, GetRenderBounds(), 0 ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_slider.h b/lib/gwen/controls/gwen_slider.h new file mode 100644 index 0000000..539c2e9 --- /dev/null +++ b/lib/gwen/controls/gwen_slider.h @@ -0,0 +1,86 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SLIDER_H +#define GWEN_CONTROLS_SLIDER_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_dragger.h" +#include "../gwen.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT SliderBar : public ControlsInternal::Dragger + { + GWEN_CONTROL( SliderBar, ControlsInternal::Dragger ); + + virtual void Render( Skin::Base* skin ); + virtual void SetHorizontal( bool b ){ m_bHorizontal = b; } + virtual bool IsHorizontal(){ return m_bHorizontal; } + + protected: + + bool m_bHorizontal; + }; + } + + namespace Controls + { + + class GWEN_EXPORT Slider : public Base + { + GWEN_CONTROL( Slider, Base ); + + virtual void Render( Skin::Base* skin ) = 0; + virtual void Layout( Skin::Base* skin ); + + virtual void SetClampToNotches( bool bClamp ) { m_bClampToNotches = bClamp; } + + virtual void SetNotchCount( int num ) { m_iNumNotches = num; } + virtual int GetNotchCount() { return m_iNumNotches; } + + virtual void SetRange( float fMin, float fMax ); + virtual float GetFloatValue(); + virtual void SetFloatValue( float val, bool forceUpdate = true ); + + virtual float CalculateValue(); + virtual void OnMoved( Controls::Base * control ); + + virtual void OnMouseClickLeft( int /*x*/, int /*y*/, bool /*bDown*/ ){}; + + virtual bool OnKeyRight( bool bDown ) { if ( bDown ) SetFloatValue( GetFloatValue() + 1, true ); return true; } + virtual bool OnKeyLeft( bool bDown ) { if ( bDown ) SetFloatValue( GetFloatValue() - 1, true ); return true; } + virtual bool OnKeyUp( bool bDown ) { if ( bDown ) SetFloatValue( GetFloatValue() + 1, true ); return true; } + virtual bool OnKeyDown( bool bDown ) { if ( bDown ) SetFloatValue( GetFloatValue() - 1, true ); return true; } + + virtual void RenderFocus( Gwen::Skin::Base* skin); + + Gwen::Event::Caller onValueChanged; + + protected: + + virtual void SetValueInternal( float fVal ); + virtual void UpdateBarFromValue() = 0; + + ControlsInternal::SliderBar * m_SliderBar; + bool m_bClampToNotches; + int m_iNumNotches; + float m_fValue; + + float m_fMin; + float m_fMax; + + }; + } + + +} +#endif diff --git a/lib/gwen/controls/gwen_splitterbar.cpp b/lib/gwen/controls/gwen_splitterbar.cpp new file mode 100644 index 0000000..dce4ed4 --- /dev/null +++ b/lib/gwen/controls/gwen_splitterbar.cpp @@ -0,0 +1,17 @@ + +#include "../gwen.h" +#include "gwen_splitterbar.h" + +using namespace Gwen; +using namespace Controls; + +GWEN_CONTROL_CONSTRUCTOR( SplitterBar ) +{ + SetTarget( this ); + RestrictToParent( true ); +} + +void SplitterBar::Layout( Skin::Base* /*skin*/ ) +{ + MoveTo( X(), Y() ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_splitterbar.h b/lib/gwen/controls/gwen_splitterbar.h new file mode 100644 index 0000000..8837c8a --- /dev/null +++ b/lib/gwen/controls/gwen_splitterbar.h @@ -0,0 +1,23 @@ +#pragma once +#ifndef GWEN_CONTROLS_SPLITTERBAR_H +#define GWEN_CONTROLS_SPLITTERBAR_H + +#include "../gwen.h" +#include "gwen_base.h" +#include "gwen_dragger.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT SplitterBar : public ControlsInternal::Dragger + { + public: + + GWEN_CONTROL( SplitterBar, ControlsInternal::Dragger ); + + void Layout( Skin::Base* skin ); + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_splitters.h b/lib/gwen/controls/gwen_splitters.h new file mode 100644 index 0000000..de39c1d --- /dev/null +++ b/lib/gwen/controls/gwen_splitters.h @@ -0,0 +1,139 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_SPLITTERS_H +#define GWEN_CONTROLS_SPLITTERS_H + +#include "gwen_base.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT SplitterVertical : public Controls::Base + { + GWEN_CONTROL_INLINE( SplitterVertical, Controls::Base ) + { + m_Panels[0] = new Controls::Base( this ); + m_Panels[1] = new Controls::Base( this ); + + m_pSplitter = new Controls::SplitterBar( this ); + + m_SplitterSize = 6; + + m_pSplitter->SetPos( 0, 100 ); + m_pSplitter->SetCursor( Gwen::CursorType::SizeNS ); + + m_pSplitter->onDragged.Add( this, &ThisClass::OnSplitterMoved ); + + SetScaling( false, 100 ); + } + + virtual void PostLayout( Skin::Base* skin ) + { + RefreshContainers(); + } + + void SetPanels( Controls::Base* pA, Controls::Base* pB ) + { + if ( pA ) pA->SetParent( m_Panels[0] ); + if ( pB ) pB->SetParent( m_Panels[1] ); + } + + void SetScaling( bool Right, int iSize ) + { + m_RightSided = Right; + m_Size = iSize; + } + + virtual int SplitterPos() + { + return m_pSplitter->Y(); + } + + protected: + + virtual void RefreshContainers() + { + const Gwen::Rect& inner = GetInnerBounds(); + + int iOffset = m_Size; + if ( m_RightSided ) iOffset = Height() - m_Size; + + m_pSplitter->SetSize( inner.w, m_SplitterSize ); + m_pSplitter->SetPos( 0, iOffset ); + + m_Panels[0]->SetPos( inner.x, inner.y ); + m_Panels[0]->SetSize( inner.w, iOffset ); + + m_Panels[1]->SetPos( inner.x, (iOffset + m_SplitterSize) ); + m_Panels[1]->SetSize( inner.w, (inner.y + inner.h) - (iOffset + m_SplitterSize) ); + } + + virtual void OnSplitterMoved() + { + if ( m_RightSided ) + m_Size = Height() - m_pSplitter->Y(); + else + m_Size = m_pSplitter->Y(); + + RefreshContainers(); + Invalidate(); + } + + Controls::Base* m_Panels[2]; + bool m_RightSided; + int m_Size; + Controls::SplitterBar* m_pSplitter; + unsigned int m_SplitterSize; + }; + + class GWEN_EXPORT SplitterHorizontal : public SplitterVertical + { + GWEN_CONTROL_INLINE( SplitterHorizontal, SplitterVertical ) + { + m_pSplitter->SetCursor( Gwen::CursorType::SizeWE ); + m_pSplitter->SetPos( 100, 0 ); + } + + virtual void RefreshContainers() + { + const Gwen::Rect& inner = GetInnerBounds(); + + int iOffset = m_Size; + if ( m_RightSided ) iOffset = Width() - m_Size; + + m_pSplitter->SetSize( m_SplitterSize, inner.h ); + m_pSplitter->SetPos( iOffset, 0 ); + + m_Panels[0]->SetPos( inner.x, inner.y ); + m_Panels[0]->SetSize( iOffset, inner.h ); + + m_Panels[1]->SetPos( (iOffset + m_SplitterSize), inner.y ); + m_Panels[1]->SetSize( (inner.x + inner.w) - (iOffset + m_SplitterSize), inner.h ); + } + + virtual void OnSplitterMoved() + { + if ( m_RightSided ) + m_Size = Width() - m_pSplitter->X(); + else + m_Size = m_pSplitter->X(); + + RefreshContainers(); + Invalidate(); + } + + virtual int SplitterPos() + { + return m_pSplitter->X(); + } + }; + } +} + +#endif diff --git a/lib/gwen/controls/gwen_statusbar.h b/lib/gwen/controls/gwen_statusbar.h new file mode 100644 index 0000000..23d609e --- /dev/null +++ b/lib/gwen/controls/gwen_statusbar.h @@ -0,0 +1,38 @@ +#pragma once +#ifndef GWEN_CONTROLS_STATUSBAR_H +#define GWEN_CONTROLS_STATUSBAR_H + +#include "../gwen.h" +#include "gwen_label.h" + +namespace Gwen +{ + namespace Controls + { + class StatusBar : public Controls::Label + { + public: + + GWEN_CONTROL_INLINE( StatusBar, Controls::Label ) + { + SetHeight( 22 ); + Dock( Pos::Bottom ); + SetPadding( Padding( 2, 2, 2, 2 ) ); + SetText( "" ); + SetAlignment( Pos::Left | Pos::CenterV ); + } + + virtual void AddControl( Controls::Base* pCtrl, bool bRight ) + { + pCtrl->SetParent( this ); + pCtrl->Dock( bRight ? Pos::Right : Pos::Left ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawStatusBar( this ); + } + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_tabbutton.cpp b/lib/gwen/controls/gwen_tabbutton.cpp new file mode 100644 index 0000000..ab9da25 --- /dev/null +++ b/lib/gwen/controls/gwen_tabbutton.cpp @@ -0,0 +1,128 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_tabbutton.h" +#include "gwen_tabcontrol.h" +#include "gwen_highlight.h" +#include "../gwen_draganddrop.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( TabButton ) +{ + m_Page = NULL; + m_Control = NULL; + + DragAndDrop_SetPackage( true, "TabButtonMove" ); + SetAlignment( Pos::Top | Pos::Left ); + SetTextPadding( Padding( 2, 2, 2, 2 ) ); +} + +void TabButton::Layout( Skin::Base* skin ) +{ + int iParentDock = m_Control->GetTabStrip()->GetDock(); + + if ( iParentDock == Pos::Bottom ) + SetPadding( Padding( 3, 1, 5, 4 ) ); + else if ( iParentDock == Pos::Top ) + SetPadding( Padding( 3, 3, 5, 2 ) ); + else + SetPadding( Padding( 3, 2, 5, 2 ) ); + + BaseClass::Layout( skin ); +} + +void TabButton::Render( Skin::Base* skin ) +{ + skin->DrawTabButton( this, IsActive(), m_Control->GetTabStrip()->GetDock() ); +} + +void TabButton::SetTabControl( TabControl* ctrl ) +{ + if ( m_Control == ctrl ) return; + + if ( m_Control ) + { + m_Control->OnLoseTab( this ); + } + + m_Control = ctrl; +} + +bool TabButton::DragAndDrop_ShouldStartDrag() +{ + return m_Control->DoesAllowDrag(); +} + + +bool TabButton::OnKeyUp( bool bDown ) +{ + OnKeyLeft( bDown ); + return true; +} +bool TabButton::OnKeyDown( bool bDown ) +{ + OnKeyRight( bDown ); + return true; +} + +bool TabButton::OnKeyLeft( bool bDown ) +{ + if ( bDown ) + { + Base::List::reverse_iterator it = stl::find( m_Parent->Children.rbegin(), m_Parent->Children.rend(), this ); + if ( it != m_Parent->Children.rend() && (++it != m_Parent->Children.rend()) ) + { + Base* pNextTab = *it; + GetTabControl()->OnTabPressed( pNextTab ); + Gwen::KeyboardFocus = pNextTab; + } + } + + return true; +} +bool TabButton::OnKeyRight( bool bDown ) +{ + if ( bDown ) + { + Base::List::iterator it = stl::find( m_Parent->Children.begin(), m_Parent->Children.end(), this ); + if ( it != m_Parent->Children.end() && (++it != m_Parent->Children.end()) ) + { + Base* pNextTab = *it; + GetTabControl()->OnTabPressed( pNextTab ); + Gwen::KeyboardFocus = pNextTab; + } + } + + return true; +} + +void TabButton::UpdateColours() +{ + if ( !IsActive() ) + { + SetImageAlpha( 0.5 ); + + if ( IsDisabled() ) return SetTextColor( GetSkin()->Colors.Tab.Inactive.Disabled ); + if ( IsDepressed() ) return SetTextColor( GetSkin()->Colors.Tab.Inactive.Down ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Tab.Inactive.Hover ); + + return SetTextColor( GetSkin()->Colors.Tab.Inactive.Normal ); + } + + SetImageAlpha( 1.0 ); + + if ( IsDisabled() ) return SetTextColor( GetSkin()->Colors.Tab.Active.Disabled ); + if ( IsDepressed() ) return SetTextColor( GetSkin()->Colors.Tab.Active.Down ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Tab.Active.Hover ); + + SetTextColor( GetSkin()->Colors.Tab.Active.Normal ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_tabbutton.h b/lib/gwen/controls/gwen_tabbutton.h new file mode 100644 index 0000000..d83bad2 --- /dev/null +++ b/lib/gwen/controls/gwen_tabbutton.h @@ -0,0 +1,58 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TABBUTTON_H +#define GWEN_CONTROLS_TABBUTTON_H + +#include "gwen_base.h" +#include "gwen_button.h" + +namespace Gwen +{ + namespace Controls + { + class TabControl; + + class GWEN_EXPORT TabButton : public Button + { + public: + + GWEN_CONTROL( TabButton, Button ); + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + + void SetPage( Base* page ){ m_Page = page; } + Base* GetPage(){ return m_Page; } + + void SetTabControl( TabControl* ctrl ); + TabControl* GetTabControl(){ return m_Control; } + + bool IsActive() { return m_Page && m_Page->Visible(); } + + virtual bool DragAndDrop_ShouldStartDrag(); + virtual void DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ){ SetHidden( true ); } + virtual void DragAndDrop_EndDragging( bool /*bSuccess*/, int /*x*/, int /*y*/ ){ SetHidden( false ); SetDepressed( false ); } + + virtual bool OnKeyLeft( bool bDown ); + virtual bool OnKeyRight( bool bDown ); + virtual bool OnKeyUp( bool bDown ); + virtual bool OnKeyDown( bool bDown ); + + virtual void UpdateColours(); + + virtual bool ShouldClip(){ return false; } + + private: + + Base* m_Page; + TabControl* m_Control; + + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_tabcontrol.cpp b/lib/gwen/controls/gwen_tabcontrol.cpp new file mode 100644 index 0000000..6501402 --- /dev/null +++ b/lib/gwen/controls/gwen_tabcontrol.cpp @@ -0,0 +1,224 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_tabcontrol.h" +#include "gwen_highlight.h" +#include "../gwen_draganddrop.h" +#include "gwen_windowcontrol.h" +#include "gwen_scrollbarbutton.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class TabControlInner : public Base +{ + public: + + GWEN_CONTROL_INLINE( TabControlInner, Base ) + { + } + + void Render( Skin::Base* skin ) + { + skin->DrawTabControl( this ); + } +}; + +GWEN_CONTROL_CONSTRUCTOR( TabControl ) +{ + m_iScrollOffset = 0; + m_pCurrentButton = NULL; + + m_TabStrip = new TabStrip( this ); + m_TabStrip->SetTabPosition( Pos::Top ); + + // Make this some special control? + m_pScroll[0] = new ControlsInternal::ScrollBarButton( this ); + m_pScroll[0]->SetDirectionLeft(); + m_pScroll[0]->onPress.Add( this, &TabControl::ScrollPressLeft ); + m_pScroll[0]->SetSize( 14, 14 ); + + m_pScroll[1] = new ControlsInternal::ScrollBarButton( this ); + m_pScroll[1]->SetDirectionRight(); + m_pScroll[1]->onPress.Add( this, &TabControl::ScrollPressRight ); + m_pScroll[1]->SetSize( 14, 14 ); + + m_InnerPanel = new TabControlInner( this ); + m_InnerPanel->Dock( Pos::Fill ); + + + m_InnerPanel->SendToBack(); + + SetTabable( false ); +} + +TabButton* TabControl::AddPage( TextObject strText, Controls::Base* pPage ) +{ + if ( !pPage ) + { + pPage = new Base( this ); + } + else + { + pPage->SetParent( this ); + } + + TabButton* pButton = new TabButton( m_TabStrip ); + pButton->SetText( strText ); + pButton->SetPage( pPage ); + pButton->SetTabable( false ); + + AddPage( pButton ); + return pButton; +} + +void TabControl::RemovePage( TabButton* pButton ) +{ + pButton->SetParent( GetCanvas() ); + OnLoseTab( pButton ); +} + +void TabControl::AddPage( TabButton* pButton ) +{ + Base* pPage = pButton->GetPage(); + pPage->SetParent( this ); + pPage->SetHidden( true ); + pPage->SetMargin( Margin( 6, 6, 6, 6 ) ); + pPage->Dock( Pos::Fill ); + + pButton->SetParent( m_TabStrip ); + pButton->Dock( Pos::Left ); + pButton->SizeToContents(); + if ( pButton->GetTabControl() ) pButton->onPress.RemoveHandler( pButton->GetTabControl() ); + pButton->SetTabControl( this ); + pButton->onPress.Add( this, &TabControl::OnTabPressed ); + + if ( !m_pCurrentButton ) + { + pButton->OnPress(); + } + + onAddTab.Call( this ); + + Invalidate(); +} + +void TabControl::OnTabPressed( Controls::Base* control ) +{ + TabButton* pButton = gwen_cast(control); + if ( !pButton ) return; + + Base* pPage = pButton->GetPage(); + if ( !pPage ) return; + + if ( m_pCurrentButton == pButton) + return; + + if ( m_pCurrentButton ) + { + Base* pPage = m_pCurrentButton->GetPage(); + if ( pPage ) + { + pPage->SetHidden( true ); + } + + m_pCurrentButton->Redraw(); + m_pCurrentButton = NULL; + } + + m_pCurrentButton = pButton; + + pPage->SetHidden( false ); + + m_TabStrip->Invalidate(); + Invalidate(); +} + +void TabControl::PostLayout( Skin::Base* skin ) +{ + BaseClass::PostLayout( skin ); + + HandleOverflow(); +} + +void TabControl::OnLoseTab( TabButton* pButton ) +{ + if ( m_pCurrentButton == pButton ) + m_pCurrentButton = NULL; + + //TODO: Select a tab if any exist. + + onLoseTab.Call( this ); + + Invalidate(); +} + +int TabControl::TabCount( void ) +{ + return m_TabStrip->NumChildren(); +} + +TabButton* TabControl::GetTab( int iNum ) +{ + return gwen_cast( m_TabStrip->GetChild( iNum ) ); +} + +void TabControl::SetTabStripPosition( int iDock ) +{ + m_TabStrip->SetTabPosition( iDock ); +} + +bool TabControl::DoesAllowDrag() +{ + return m_TabStrip->AllowsTabReorder(); +} + +void TabControl::HandleOverflow() +{ + Gwen::Point TabsSize = m_TabStrip->ChildrenSize(); + + // Only enable the scrollers if the tabs are at the top. + // This is a limitation we should explore. + // Really TabControl should have derivitives for tabs placed elsewhere where we could specialize + // some functions like this for each direction. + bool bNeeded = TabsSize.x > Width() && m_TabStrip->GetDock() == Pos::Top; + + m_pScroll[0]->SetHidden( !bNeeded ); + m_pScroll[1]->SetHidden( !bNeeded ); + + if ( !bNeeded ) return; + + m_iScrollOffset = Gwen::Clamp( m_iScrollOffset, 0, TabsSize.x - Width() + 32 ); + + #if 0 + // + // This isn't frame rate independent. + // Could be better. Get rid of m_iScrollOffset and just use m_TabStrip->GetMargin().left ? + // Then get a margin animation type and do it properly! + // TODO! + // + m_TabStrip->SetMargin( Margin( Gwen::Approach( m_TabStrip->GetMargin().left, m_iScrollOffset * -1, 2 ), 0, 0, 0 ) ); + InvalidateParent(); + #else + m_TabStrip->SetMargin( Margin( m_iScrollOffset * -1, 0, 0, 0 ) ); + #endif + + m_pScroll[0]->SetPos( Width() - 30 , 5 ); + m_pScroll[1]->SetPos( m_pScroll[0]->Right(), 5 ); +} + +void TabControl::ScrollPressLeft( Base* pFrom ) +{ + m_iScrollOffset -= 120; +} + +void TabControl::ScrollPressRight( Base* pFrom ) +{ + m_iScrollOffset += 120; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_tabcontrol.h b/lib/gwen/controls/gwen_tabcontrol.h new file mode 100644 index 0000000..b22857f --- /dev/null +++ b/lib/gwen/controls/gwen_tabcontrol.h @@ -0,0 +1,70 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TABCONTROL_H +#define GWEN_CONTROLS_TABCONTROL_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_tabbutton.h" +#include "gwen_tabstrip.h" +#include "gwen_tabtitlebar.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class ScrollBarButton; + } + + namespace Controls + { + class GWEN_EXPORT TabControl : public Base + { + GWEN_CONTROL( TabControl, Base ); + + virtual TabButton* AddPage( const TextObject strText, Controls::Base* pPage = NULL ); + + virtual void AddPage( TabButton* pButton ); + virtual void RemovePage( TabButton* pButton ); + + virtual void OnTabPressed( Controls::Base* control ); + virtual void OnLoseTab( TabButton* pButton ); + + virtual int TabCount( void ); + virtual TabButton* GetTab( int iNum ); + virtual TabButton* GetCurrentButton(){ return m_pCurrentButton; } + virtual TabStrip* GetTabStrip(){ return m_TabStrip; } + + virtual void SetTabStripPosition( int iDock ); + + virtual bool DoesAllowDrag(); + + virtual void SetAllowReorder( bool b ){ GetTabStrip()->SetAllowReorder( b ); } + + Gwen::Event::Caller onLoseTab; + Gwen::Event::Caller onAddTab; + + private: + + virtual void PostLayout( Skin::Base* skin ); + void HandleOverflow(); + + void ScrollPressLeft( Base* pFrom ); + void ScrollPressRight( Base* pFrom ); + + TabStrip* m_TabStrip; + TabButton* m_pCurrentButton; + + ControlsInternal::ScrollBarButton* m_pScroll[2]; + int m_iScrollOffset; + + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_tabstrip.cpp b/lib/gwen/controls/gwen_tabstrip.cpp new file mode 100644 index 0000000..3c065f7 --- /dev/null +++ b/lib/gwen/controls/gwen_tabstrip.cpp @@ -0,0 +1,188 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_tabstrip.h" +#include "gwen_tabcontrol.h" +#include "gwen_highlight.h" +#include "../gwen_draganddrop.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + + +GWEN_CONTROL_CONSTRUCTOR( TabStrip ) +{ + m_TabDragControl = NULL; + m_bAllowReorder = false; +} + +bool TabStrip::DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* /*pPackage*/, int x, int y ) +{ + Gwen::Point LocalPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + + TabButton* pButton = gwen_cast( DragAndDrop::SourceControl ); + TabControl* pTabControl = gwen_cast( GetParent() ); + if ( pTabControl && pButton ) + { + if ( pButton->GetTabControl() != pTabControl ) + { + // We've moved tab controls! + pTabControl->AddPage( pButton ); + } + } + + Base* DroppedOn = GetControlAt( LocalPos.x, LocalPos.y ); + if ( DroppedOn ) + { + Gwen::Point DropPos = DroppedOn->CanvasPosToLocal( Gwen::Point( x, y ) ); + DragAndDrop::SourceControl->BringNextToControl( DroppedOn, DropPos.x > DroppedOn->Width() / 2 ); + } + else + { + DragAndDrop::SourceControl->BringToFront(); + } + return true; +} + +bool TabStrip::DragAndDrop_CanAcceptPackage( Gwen::DragAndDrop::Package* pPackage ) +{ + if ( !m_bAllowReorder ) + return false; + + if ( pPackage->name == "TabButtonMove" ) + return true; + + return false; +} + +void TabStrip::Layout( Skin::Base* skin ) +{ + Gwen::Point pLargestTab( 5, 5 ); + + int iNum = 0; + for ( Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter ) + { + TabButton* pButton = gwen_cast(*iter); + if ( !pButton ) continue; + + pButton->SizeToContents(); + + Margin m; + int iNotFirst = iNum > 0 ? -1 : 0; + + if ( m_iDock == Pos::Top ) + { + m.left = iNotFirst; + pButton->Dock( Pos::Left ); + } + + if ( m_iDock == Pos::Left ) + { + m.top = iNotFirst; + pButton->Dock( Pos::Top ); + } + + if ( m_iDock == Pos::Right ) + { + m.top = iNotFirst; + pButton->Dock( Pos::Top ); + } + + if ( m_iDock == Pos::Bottom ) + { + m.left = iNotFirst; + pButton->Dock( Pos::Left ); + } + + pLargestTab.x = Utility::Max( pLargestTab.x, pButton->Width() ); + pLargestTab.y = Utility::Max( pLargestTab.y, pButton->Height() ); + + pButton->SetMargin( m ); + iNum++; + } + + if ( m_iDock == Pos::Top || m_iDock == Pos::Bottom ) + SetSize( Width(), pLargestTab.y ); + + if ( m_iDock == Pos::Left || m_iDock == Pos::Right ) + SetSize( pLargestTab.x, Height() ); + + BaseClass::Layout( skin ); +} + +void TabStrip::DragAndDrop_HoverEnter( Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/ ) +{ + if ( m_TabDragControl ) + { + Debug::Msg( "ERROR! TabStrip::DragAndDrop_HoverEnter\n" ); + } + + m_TabDragControl = new ControlsInternal::Highlight( this ); + m_TabDragControl->SetMouseInputEnabled( false ); + m_TabDragControl->SetSize( 3, Height() ); +} + +void TabStrip::DragAndDrop_HoverLeave( Gwen::DragAndDrop::Package* /*pPackage*/ ) +{ + delete m_TabDragControl; + m_TabDragControl = NULL; +} + +void TabStrip::DragAndDrop_Hover( Gwen::DragAndDrop::Package* /*pPackage*/, int x, int y ) +{ + Gwen::Point LocalPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + + Base* DroppedOn = GetControlAt( LocalPos.x, LocalPos.y ); + if ( DroppedOn && DroppedOn != this ) + { + Gwen::Point DropPos = DroppedOn->CanvasPosToLocal( Gwen::Point( x, y ) ); + m_TabDragControl->SetBounds( Gwen::Rect( 0, 0, 3, Height() ) ); + m_TabDragControl->BringToFront(); + m_TabDragControl->SetPos( DroppedOn->X() - 1, 0 ); + + if ( DropPos.x > DroppedOn->Width() / 2 ) + { + m_TabDragControl->MoveBy( DroppedOn->Width()-1, 0 ); + } + m_TabDragControl->Dock( Pos::None ); + } + else + { + m_TabDragControl->Dock( Pos::Left ); + m_TabDragControl->BringToFront(); + } +} + +void TabStrip::SetTabPosition( int iPos ) +{ + Dock( iPos ); + + if ( m_iDock == Pos::Top ) + { + SetPadding( Padding( 5, 0, 0, 0 ) ); + } + + if ( m_iDock == Pos::Left ) + { + SetPadding( Padding( 0, 5, 0, 0 ) ); + } + + if ( m_iDock == Pos::Right ) + { + SetPadding( Padding( 0, 5, 0, 0 ) ); + } + + if ( m_iDock == Pos::Bottom ) + { + SetPadding( Padding( 5, 0, 0, 0 ) ); + } + + InvalidateChildren( true ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_tabstrip.h b/lib/gwen/controls/gwen_tabstrip.h new file mode 100644 index 0000000..da20cff --- /dev/null +++ b/lib/gwen/controls/gwen_tabstrip.h @@ -0,0 +1,51 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TABSTRIP_H +#define GWEN_CONTROLS_TABSTRIP_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_tabbutton.h" + +namespace Gwen +{ + namespace Controls + { + //class TabControl; + + class GWEN_EXPORT TabStrip : public Base + { + public: + + GWEN_CONTROL( TabStrip, Base ); + + virtual void Layout( Skin::Base* skin ); + + virtual bool DragAndDrop_HandleDrop( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual bool DragAndDrop_CanAcceptPackage( Gwen::DragAndDrop::Package* pPackage ); + + virtual void DragAndDrop_HoverEnter( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + virtual void DragAndDrop_HoverLeave( Gwen::DragAndDrop::Package* pPackage ); + virtual void DragAndDrop_Hover( Gwen::DragAndDrop::Package* pPackage, int x, int y ); + + virtual void SetTabPosition( int iPos ); + + virtual void SetAllowReorder( bool b ){ m_bAllowReorder = b; } + virtual bool AllowsTabReorder() { return m_bAllowReorder; } + + virtual bool ShouldClip(){ return false; } + + private: + + Base* m_TabDragControl; + bool m_bAllowReorder; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_tabtitlebar.h b/lib/gwen/controls/gwen_tabtitlebar.h new file mode 100644 index 0000000..43795e1 --- /dev/null +++ b/lib/gwen/controls/gwen_tabtitlebar.h @@ -0,0 +1,56 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TABTITLEBAR_H +#define GWEN_CONTROLS_TABTITLEBAR_H + +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_tabbutton.h" +#include "../gwen_draganddrop.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT TabTitleBar : public Label + { + public: + + GWEN_CONTROL_INLINE( TabTitleBar, Label ) + { + SetMouseInputEnabled( true ); + SetTextPadding( Gwen::Padding( 5, 2, 5, 2 ) ); + SetPadding( Gwen::Padding( 1, 2, 1, 2 ) ); + + DragAndDrop_SetPackage( true, "TabWindowMove" ); + } + + void Render( Skin::Base* skin ) + { + skin->DrawTabTitleBar( this ); + } + + void DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y ) + { + DragAndDrop::SourceControl = GetParent(); + DragAndDrop::SourceControl->DragAndDrop_StartDragging( pPackage, x, y ); + } + + void UpdateFromTab( TabButton* pButton ) + { + SetText( pButton->GetText() ); + SizeToContents(); + } + + private: + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_text.cpp b/lib/gwen/controls/gwen_text.cpp new file mode 100644 index 0000000..cbe2131 --- /dev/null +++ b/lib/gwen/controls/gwen_text.cpp @@ -0,0 +1,402 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_text.h" +#include "../gwen_skin.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::ControlsInternal; + +GWEN_CONTROL_CONSTRUCTOR( Text ) +{ + m_Font = NULL; + m_ColorOverride = Color( 255, 255, 255, 0 ); + m_Color = GetSkin()->Colors.Label.Default; + SetMouseInputEnabled( false ); + SetWrap( false ); +} + +Text::~Text() +{ + // NOTE: This font doesn't need to be released + // Because it's a pointer to another font somewhere. +} + +void Text::Layout( Skin::Base* skin ) +{ + if ( m_bTextChanged ) + { + RefreshSize(); + m_bTextChanged = false; + } +} + +Gwen::Font* Text::GetFont() +{ + return m_Font; +} + +void Text::SetFont( Gwen::Font* pFont ) +{ + if ( m_Font == pFont ) return; + + m_Font = pFont; + m_bTextChanged = true; + + // Change the font of multilines too! + { + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + while ( it != itEnd ) + { + (*it)->SetFont( m_Font ); + ++it; + } + } + + Invalidate(); +} + +void Text::SetString( const TextObject& str ) +{ + if ( m_String == str ) return; + + m_String = str.Get(); + m_bTextChanged = true; + Invalidate(); +} + +void Text::Render( Skin::Base* skin ) +{ + if ( m_bWrap ) return; + if ( Length() == 0 || !GetFont() ) return; + + if ( m_ColorOverride.a == 0 ) + skin->GetRender()->SetDrawColor( m_Color ); + else + skin->GetRender()->SetDrawColor( m_ColorOverride ); + + skin->GetRender()->RenderText( GetFont(), Gwen::Point( GetPadding().left, GetPadding().top ), m_String.Get() ); +} + +Gwen::Rect Text::GetCharacterPosition( int iChar ) +{ + if ( !m_Lines.empty() ) + { + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + int iChars = 0; + + while ( it != itEnd ) + { + Text* pLine = *it; + ++it; + iChars += pLine->Length(); + + if ( iChars <= iChar ) continue; + + iChars -= pLine->Length(); + + Gwen::Rect rect = pLine->GetCharacterPosition( iChar - iChars ); + rect.x += pLine->X(); + rect.y += pLine->Y(); + + return rect; + } + } + + if ( Length() == 0 || iChar == 0 ) + { + Gwen::Point p = GetSkin()->GetRender()->MeasureText( GetFont(), " " ); + return Gwen::Rect( 1, 0, 0, p.y ); + } + + String sub = m_String.Get().substr( 0, iChar ); + Gwen::Point p = GetSkin()->GetRender()->MeasureText( GetFont(), sub ); + + return Rect( p.x, 0, 0, p.y ); +} + +int Text::GetClosestCharacter( Gwen::Point p ) +{ + if ( !m_Lines.empty() ) + { + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + int iChars = 0; + + while ( it != itEnd ) + { + Text* pLine = *it; + ++it; + + iChars += pLine->Length(); + + if ( p.y < pLine->Y() ) continue; + if ( p.y > pLine->Bottom() ) continue; + + iChars -= pLine->Length(); + + int iLinePos = pLine->GetClosestCharacter( Gwen::Point( p.x - pLine->X(), p.y - pLine->Y() ) ); + //if ( iLinePos > 0 && iLinePos == pLine->Length() ) iLinePos--; + iLinePos--; + + return iChars + iLinePos; + } + } + + + int iDistance = 4096; + int iChar = 0; + + for ( size_t i=0; i iDistance ) continue; + + iDistance = iDist; + iChar = i; + } + + return iChar; +} + +void Text::OnScaleChanged() +{ + Invalidate(); +} + +void Text::RefreshSize() +{ + if ( m_bWrap ) + { + return RefreshSizeWrap(); + } + + if ( !GetFont() ) + { + Debug::AssertCheck( 0, "Text::RefreshSize() - No Font!!\n" ); + return; + } + + Gwen::Point p( 1, GetFont()->size ); + + if ( Length() > 0 ) + { + p = GetSkin()->GetRender()->MeasureText( GetFont(), m_String.Get() ); + } + + p.x += GetPadding().left + GetPadding().right; + p.y += GetPadding().top + GetPadding().bottom; + + if ( p.x == Width() && p.y == Height() ) + return; + + if ( p.y < GetFont()->size ) p.y = GetFont()->size; + + SetSize( p.x, p.y ); + InvalidateParent(); + Invalidate(); +} + +void SplitWords(const Gwen::String &s, char delim, stl::vector &elems) +{ + Gwen::String str; + + for ( unsigned int i=0; i words; + SplitWords( GetText().Get(), ' ', words ); + + // Adding a bullshit word to the end simplifies the code below + // which is anything but simple. + words.push_back( "" ); + + if ( !GetFont() ) + { + Debug::AssertCheck( 0, "Text::RefreshSize() - No Font!!\n" ); + return; + } + + Point pFontSize = GetSkin()->GetRender()->MeasureText( GetFont(), " " ); + + int w = GetParent()->Width(); + int x = 0, y = 0; + + Gwen::String strLine; + + stl::vector::iterator it = words.begin(); + for (; it != words.end(); ++it ) + { + bool bFinishLine = false; + //bool bWrapped = false; + + // If this word is a newline - make a newline (we still add it to the text) + if ( (*it).c_str()[0] == '\n' ) bFinishLine = true; + + // Does adding this word drive us over the width? + { + strLine += (*it); + Gwen::Point p = GetSkin()->GetRender()->MeasureText( GetFont(), strLine ); + if ( p.x > Width() ) { bFinishLine = true; /*bWrapped = true;*/ } + } + + // If this is the last word then finish the line + // if ( --words.end() == it ) + // NOTE: replaced above commented out 'if' statement with this to appease + // the GCC compiler that comes with Marmalade SDK 6.0 + stl::vector::iterator temp = words.end() - 1; + if ( temp == it ) + { + bFinishLine = true; + } + + if ( bFinishLine ) + { + Text* t = new Text( this ); + t->SetFont( GetFont() ); + t->SetString( strLine.substr( 0, strLine.length() - (*it).length() ) ); + t->RefreshSize(); + t->SetPos( x, y ); + m_Lines.push_back( t ); + + // newline should start with the word that was too big + strLine = *it; + + // Position the newline + y += pFontSize.y; + x = 0; + + //if ( strLine[0] == ' ' ) x -= pFontSize.x; + } + + } + + // Size to children height and parent width + { + Point childsize = ChildrenSize(); + SetSize( w, childsize.y ); + } + + InvalidateParent(); + Invalidate(); +} + +int Text::NumLines() +{ + return m_Lines.size(); +} + +Text* Text::GetLine( int i ) +{ + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + + while ( it != itEnd ) + { + if ( i == 0 ) return *it; + ++it; + i--; + } + + return NULL; +} + +int Text::GetLineFromChar( int i ) +{ + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + int iChars = 0; + int iLine = 0; + + while ( it != itEnd ) + { + Text* pLine = *it; + ++it; + + iChars += pLine->Length(); + + if ( iChars > i ) return iLine; + iLine++; + } + + return iLine; +} + +int Text::GetStartCharFromLine( int i ) +{ + TextLines::iterator it = m_Lines.begin(); + TextLines::iterator itEnd = m_Lines.end(); + int iChars = 0; + + while ( it != itEnd ) + { + Text* pLine = *it; + ++it; + if ( i == 0 ) return Gwen::Clamp( iChars, 0, Length() ); + + iChars += pLine->Length(); + i--; + } + + return Gwen::Clamp( iChars, 0, Length() ); +} + +int Text::GetEndCharFromLine( int i ) +{ + int iStart = GetStartCharFromLine( i ); + Text* iLine = GetLine( i ); + + if ( iLine ) + { + iStart += iLine->Length(); + } + + return Gwen::Clamp( iStart, 0, Length() ); +} + +int Text::GetCharPosOnLine( int i ) +{ + int iLine = GetLineFromChar( i ); + Text* line = GetLine( iLine ); + if ( !line ) return 0; + + int iStart = GetStartCharFromLine( iLine ); + + return i - iStart; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_text.h b/lib/gwen/controls/gwen_text.h new file mode 100644 index 0000000..01f7216 --- /dev/null +++ b/lib/gwen/controls/gwen_text.h @@ -0,0 +1,79 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TEXT_H +#define GWEN_CONTROLS_TEXT_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" + +namespace Gwen +{ + namespace ControlsInternal + { + class GWEN_EXPORT Text : public Controls::Base + { + public: + + GWEN_CONTROL( Text, Controls::Base ); + + virtual ~Text(); + Gwen::Font* GetFont(); + + void SetString( const TextObject& str ); + + void Render( Skin::Base* skin ); + void Layout( Skin::Base* skin ); + + void RefreshSize(); + + void SetFont( Gwen::Font* pFont ); + + const TextObject& GetText() const { return m_String; } + + Gwen::Rect GetCharacterPosition( int iChar ); + int GetClosestCharacter( Gwen::Point p ); + + int Length() const { return (int)m_String.Get().size(); } + + virtual void SetTextColor( const Gwen::Color& col ){ m_Color = col; } + virtual void SetTextColorOverride( const Gwen::Color& col ){ m_ColorOverride = col; } + + virtual void OnScaleChanged(); + + inline const Gwen::Color &TextColor() const { return m_Color; } + + virtual void TextChanged(){ m_bTextChanged = true; } + virtual bool Wrap(){ return m_bWrap; } + virtual void SetWrap( bool b ){ if ( m_bWrap == b ) return; m_bWrap = b; m_bTextChanged = true; Invalidate(); } + + virtual Text* GetLine( int i ); + virtual int GetLineFromChar( int i ); + virtual int GetStartCharFromLine( int i ); + virtual int GetEndCharFromLine( int i ); + virtual int GetCharPosOnLine( int i ); + virtual int NumLines(); + + private: + + virtual void RefreshSizeWrap(); + + Gwen::TextObject m_String; + Gwen::Font* m_Font; + Gwen::Color m_Color; + Gwen::Color m_ColorOverride; + + bool m_bWrap; + bool m_bTextChanged; + + typedef stl::list TextLines; + TextLines m_Lines; + }; + } + +} +#endif diff --git a/lib/gwen/controls/gwen_textbox.cpp b/lib/gwen/controls/gwen_textbox.cpp new file mode 100644 index 0000000..727357c --- /dev/null +++ b/lib/gwen/controls/gwen_textbox.cpp @@ -0,0 +1,568 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_textbox.h" +#include "../gwen_skin.h" +#include "../gwen_anim.h" +#include "../gwen_utility.h" +#include "../gwen_platform.h" + +#include + +using namespace Gwen; +using namespace Gwen::Controls; + +#ifndef GWEN_NO_ANIMATION +class ChangeCaretColor : public Gwen::Anim::Animation +{ + public: + + virtual void Think() + { + gwen_cast(m_Control)->UpdateCaretColor(); + } +}; +#endif + + +GWEN_CONTROL_CONSTRUCTOR( TextBox ) +{ + SetSize( 200, 20 ); + + SetMouseInputEnabled( true ); + SetKeyboardInputEnabled( true ); + + SetAlignment( Pos::Left | Pos::CenterV ); + SetPadding( Padding( 4, 2, 4, 2 ) ); + + m_iCursorPos = 0; + m_iCursorEnd = 0; + m_iCursorLine = 0; + m_bSelectAll = false; + + SetTextColor( Gwen::Color( 50, 50, 50, 255 ) ); // TODO: From Skin + + SetTabable( true ); + + AddAccelerator( "Ctrl + C", &TextBox::OnCopy ); + AddAccelerator( "Ctrl + X", &TextBox::OnCut ); + AddAccelerator( "Ctrl + V", &TextBox::OnPaste ); + AddAccelerator( "Ctrl + A", &TextBox::OnSelectAll ); + + Gwen::Anim::Add( this, new ChangeCaretColor() ); +} + +bool TextBox::OnChar( char c ) +{ + if ( c == '\t' ) return false; + + Gwen::String str; + str += c; + + InsertText( str ); + return true; +} + +void TextBox::InsertText( const Gwen::String& strInsert ) +{ + // TODO: Make sure fits (implement maxlength) + + if ( HasSelection() ) + { + EraseSelection(); + } + + if ( m_iCursorPos > TextLength() ) m_iCursorPos = TextLength(); + + if ( !IsTextAllowed( strInsert, m_iCursorPos ) ) + return; + + String str = GetText().Get(); + str.insert( m_iCursorPos, strInsert ); + SetText( str ); + + m_iCursorPos += (int) strInsert.size(); + m_iCursorEnd = m_iCursorPos; + m_iCursorLine = 0; + + RefreshCursorBounds(); +} + +#ifndef GWEN_NO_ANIMATION +void TextBox::UpdateCaretColor() +{ + if ( m_fNextCaretColorChange > Gwen::Platform::GetTimeInSeconds() ) return; + if ( !HasFocus() ) { m_fNextCaretColorChange = Gwen::Platform::GetTimeInSeconds() + 0.5f; return; } + + Gwen::Color targetcolor = Gwen::Color( 230, 230, 230, 255 ); + + if ( m_CaretColor == targetcolor ) + targetcolor = Gwen::Color( 20, 20, 20, 255 ); + + m_fNextCaretColorChange = Gwen::Platform::GetTimeInSeconds() + 0.5; + m_CaretColor = targetcolor; + Redraw(); +} +#endif + +void TextBox::Render( Skin::Base* skin ) +{ + if ( ShouldDrawBackground() ) + skin->DrawTextBox( this ); + + if ( !HasFocus() ) return; + + // Draw selection.. if selected.. + if ( m_iCursorPos != m_iCursorEnd ) + { + skin->GetRender()->SetDrawColor( Gwen::Color( 50, 170, 255, 200 ) ); + skin->GetRender()->DrawFilledRect( m_rectSelectionBounds ); + } + + // Draw caret + skin->GetRender()->SetDrawColor( m_CaretColor ); + skin->GetRender()->DrawFilledRect( m_rectCaretBounds ); +} + +void TextBox::RefreshCursorBounds() +{ + m_fNextCaretColorChange = Gwen::Platform::GetTimeInSeconds() + 1.5f; + m_CaretColor = Gwen::Color( 30, 30, 30, 255 ); + + MakeCaratVisible(); + + Gwen::Rect pA = GetCharacterPosition( m_iCursorPos ); + Gwen::Rect pB = GetCharacterPosition( m_iCursorEnd ); + + m_rectSelectionBounds.x = Utility::Min( pA.x, pB.x ); + m_rectSelectionBounds.y = m_Text->Y() - 1; + m_rectSelectionBounds.w = Utility::Max( pA.x, pB.x ) - m_rectSelectionBounds.x; + m_rectSelectionBounds.h = m_Text->Height() + 2; + + m_rectCaretBounds.x = pA.x; + m_rectCaretBounds.y = pA.y; + m_rectCaretBounds.w = 1; + m_rectCaretBounds.h = pA.h; + + Redraw(); +} + + +void TextBox::OnPaste( Gwen::Controls::Base* /*pCtrl*/ ) +{ + InsertText( Platform::GetClipboardText() ); +} + +void TextBox::OnCopy( Gwen::Controls::Base* /*pCtrl*/ ) +{ + if ( !HasSelection() ) return; + + Platform::SetClipboardText( GetSelection() ); +} + +void TextBox::OnCut( Gwen::Controls::Base* /*pCtrl*/ ) +{ + if ( !HasSelection() ) return; + + Platform::SetClipboardText( GetSelection() ); + EraseSelection(); +} + +void TextBox::OnSelectAll( Gwen::Controls::Base* /*pCtrl*/ ) +{ + m_iCursorEnd = 0; + m_iCursorPos = TextLength(); + m_iCursorLine = 0; + + RefreshCursorBounds(); +} + +void TextBox::OnMouseDoubleClickLeft( int /*x*/, int /*y*/ ) +{ + OnSelectAll( this ); +} + +String TextBox::GetSelection() +{ + if ( !HasSelection() ) return ""; + + int iStart = Utility::Min( m_iCursorPos, m_iCursorEnd ); + int iEnd = Utility::Max( m_iCursorPos, m_iCursorEnd ); + + const String& str = GetText().Get(); + return str.substr( iStart, iEnd - iStart ); +} + +bool TextBox::OnKeyReturn( bool bDown ) +{ + if ( bDown ) return true; + + // Try to move to the next control, as if tab had been pressed + OnKeyTab( true ); + + // If we still have focus, blur it. + if ( HasFocus() ) + { + Blur(); + } + + // This is called AFTER the blurring so you can + // refocus in your onReturnPressed hook. + OnEnter(); + + return true; +} + +bool TextBox::OnKeyBackspace( bool bDown ) +{ + if ( !bDown ) return true; + if ( HasSelection() ) + { + EraseSelection(); + return true; + } + + if ( m_iCursorPos == 0 ) return true; + + DeleteText( m_iCursorPos-1, 1 ); + + return true; +} + +bool TextBox::OnKeyDelete( bool bDown ) +{ + if ( !bDown ) return true; + if ( HasSelection() ) + { + EraseSelection(); + return true; + } + + if ( m_iCursorPos >= TextLength() ) return true; + + DeleteText( m_iCursorPos, 1 ); + + return true; +} + +bool TextBox::OnKeyLeft( bool bDown ) +{ + if ( !bDown ) return true; + + if ( m_iCursorPos > 0 ) + m_iCursorPos--; + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBox::OnKeyRight( bool bDown ) +{ + if ( !bDown ) return true; + + if ( m_iCursorPos < TextLength() ) + m_iCursorPos++; + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBox::OnKeyHome( bool bDown ) +{ + if ( !bDown ) return true; + m_iCursorPos = 0; + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBox::OnKeyEnd( bool /*bDown*/ ) +{ + m_iCursorPos = TextLength(); + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +void TextBox::SetCursorPos( int i ) +{ + if ( m_iCursorPos == i ) return; + + m_iCursorPos = i; + m_iCursorLine = 0; + RefreshCursorBounds(); +} + +void TextBox::SetCursorEnd( int i ) +{ + if ( m_iCursorEnd == i ) return; + + m_iCursorEnd = i; + RefreshCursorBounds(); +} + + +void TextBox::DeleteText( int iStartPos, int iLength ) +{ + String str = GetText().Get(); + str.erase( iStartPos, iLength ); + SetText( str ); + + if ( m_iCursorPos > iStartPos ) + { + SetCursorPos( m_iCursorPos - iLength ); + } + + SetCursorEnd( m_iCursorPos ); +} + +bool TextBox::HasSelection() +{ + return m_iCursorPos != m_iCursorEnd; +} + +void TextBox::EraseSelection() +{ + int iStart = Utility::Min( m_iCursorPos, m_iCursorEnd ); + int iEnd = Utility::Max( m_iCursorPos, m_iCursorEnd ); + + DeleteText( iStart, iEnd - iStart ); + + // Move the cursor to the start of the selection, + // since the end is probably outside of the string now. + m_iCursorPos = iStart; + m_iCursorEnd = iStart; +} + +void TextBox::OnMouseClickLeft( int x, int y, bool bDown ) +{ + if ( m_bSelectAll ) + { + OnSelectAll( this ); + m_bSelectAll = false; + return; + } + + int iChar = m_Text->GetClosestCharacter( m_Text->CanvasPosToLocal( Gwen::Point( x, y ) ) ); + + if ( bDown ) + { + SetCursorPos( iChar ); + + if ( !Gwen::Input::IsShiftDown() ) + SetCursorEnd( iChar ); + + Gwen::MouseFocus = this; + } + else + { + if ( Gwen::MouseFocus == this ) + { + SetCursorPos( iChar ); + Gwen::MouseFocus = NULL; + } + } +} + +void TextBox::OnMouseMoved( int x, int y, int /*deltaX*/, int /*deltaY*/ ) +{ + if ( Gwen::MouseFocus != this ) return; + + int iChar = m_Text->GetClosestCharacter( m_Text->CanvasPosToLocal( Gwen::Point( x, y ) ) ); + + SetCursorPos( iChar ); +} + +void TextBox::MakeCaratVisible() +{ + int iCaratPos = m_Text->GetCharacterPosition( m_iCursorPos ).x; + + // If the carat is already in a semi-good position, leave it. + { + int iRealCaratPos = iCaratPos + m_Text->X(); + if ( iRealCaratPos > Width() * 0.1f && iRealCaratPos < Width() * 0.9f ) + return; + } + + // The ideal position is for the carat to be right in the middle + int idealx = -iCaratPos + Width() * 0.5f;; + + // Don't show too much whitespace to the right + if ( idealx + m_Text->Width() < Width() - GetPadding().right ) + idealx = -m_Text->Width() + (Width() - GetPadding().right ); + + // Or the left + if ( idealx > GetPadding().left ) + idealx = GetPadding().left; + + m_Text->SetPos( idealx, m_Text->Y() ); + +} + +void TextBox::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + RefreshCursorBounds(); +} + +void TextBox::OnTextChanged() +{ + if ( m_iCursorPos > TextLength() ) m_iCursorPos = TextLength(); + if ( m_iCursorEnd > TextLength() ) m_iCursorEnd = TextLength(); + + onTextChanged.Call( this ); +} + +void TextBox::OnEnter() +{ + onReturnPressed.Call( this ); +} + +void TextBox::MoveCaretToEnd() +{ + m_iCursorPos = TextLength(); + m_iCursorEnd = TextLength(); + RefreshCursorBounds(); +} + +void TextBox::MoveCaretToStart() +{ + m_iCursorPos = 0; + m_iCursorEnd = 0; + RefreshCursorBounds(); +} + + +GWEN_CONTROL_CONSTRUCTOR( TextBoxMultiline ) +{ + SetWrap( true ); + SetAlignment( Pos::Left | Pos::Top ); +} + +bool TextBoxMultiline::OnKeyReturn( bool bDown ) +{ + if ( bDown ) + { + InsertText( "\n" ); + } + + return true; +} + +void TextBoxMultiline::MakeCaratVisible() +{ + // TODO. scroll vertically +} + +int TextBoxMultiline::GetCurrentLine() +{ + return m_Text->GetLineFromChar( m_iCursorPos ); +} + +bool TextBoxMultiline::OnKeyHome( bool bDown ) +{ + if ( !bDown ) return true; + + int iCurrentLine = GetCurrentLine(); + int iChar = m_Text->GetStartCharFromLine( iCurrentLine ); + + m_iCursorLine = 0; + m_iCursorPos = iChar; + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBoxMultiline::OnKeyEnd( bool bDown ) +{ + if ( !bDown ) return true; + + int iCurrentLine = GetCurrentLine(); + int iChar = m_Text->GetEndCharFromLine( iCurrentLine ); + + m_iCursorLine = 0; + m_iCursorPos = iChar-1; // NAUGHTY + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBoxMultiline::OnKeyUp( bool bDown ) +{ + if ( !bDown ) return true; + + if ( m_iCursorLine == 0 ) m_iCursorLine = m_Text->GetCharPosOnLine( m_iCursorPos ); + + int iLine = m_Text->GetLineFromChar( m_iCursorPos ); + if ( iLine == 0 ) return true; + + m_iCursorPos = m_Text->GetStartCharFromLine( iLine - 1 ); + m_iCursorPos += Clamp( m_iCursorLine, 0, m_Text->GetLine( iLine - 1)->Length() ); + m_iCursorPos = Clamp( m_iCursorPos, 0, m_Text->Length() ); + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} + +bool TextBoxMultiline::OnKeyDown( bool bDown ) +{ + if ( !bDown ) return true; + + if ( m_iCursorLine == 0 ) m_iCursorLine = m_Text->GetCharPosOnLine( m_iCursorPos ); + + int iLine = m_Text->GetLineFromChar( m_iCursorPos ); + if ( iLine >= m_Text->NumLines()-1 ) return true; + + m_iCursorPos = m_Text->GetStartCharFromLine( iLine + 1 ); + m_iCursorPos += Clamp( m_iCursorLine, 0, m_Text->GetLine( iLine + 1)->Length() ); + m_iCursorPos = Clamp( m_iCursorPos, 0, m_Text->Length() ); + + if ( !Gwen::Input::IsShiftDown() ) + { + m_iCursorEnd = m_iCursorPos; + } + + RefreshCursorBounds(); + return true; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_textbox.h b/lib/gwen/controls/gwen_textbox.h new file mode 100644 index 0000000..87cb531 --- /dev/null +++ b/lib/gwen/controls/gwen_textbox.h @@ -0,0 +1,133 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TEXTBOX_H +#define GWEN_CONTROLS_TEXTOBX_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_scrollcontrol.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT TextBox : public Label + { + GWEN_CONTROL( TextBox, Label ); + + virtual void Render( Skin::Base* skin ); + virtual void RenderFocus( Gwen::Skin::Base* /*skin*/){}; + virtual void Layout( Skin::Base* skin ); + + #ifndef GWEN_NO_ANIMATION + virtual void UpdateCaretColor(); + #endif + + virtual bool OnChar( char c ); + + virtual void InsertText( const Gwen::String& str ); + virtual void DeleteText( int iStartPos, int iLength ); + + virtual void RefreshCursorBounds(); + + virtual bool OnKeyReturn( bool bDown ); + virtual bool OnKeyBackspace( bool bDown ); + virtual bool OnKeyDelete( bool bDown ); + virtual bool OnKeyRight( bool bDown ); + virtual bool OnKeyLeft( bool bDown ); + virtual bool OnKeyHome( bool bDown ); + virtual bool OnKeyEnd( bool bDown ); + + virtual bool AccelOnlyFocus() { return true; } + + virtual void OnPaste( Gwen::Controls::Base* pCtrl ); + virtual void OnCopy( Gwen::Controls::Base* pCtrl ); + virtual void OnCut( Gwen::Controls::Base* pCtrl ); + virtual void OnSelectAll( Gwen::Controls::Base* pCtrl ); + + virtual void OnMouseDoubleClickLeft( int x, int y ); + + virtual void EraseSelection(); + virtual bool HasSelection(); + virtual String GetSelection(); + + virtual void SetCursorPos( int i ); + virtual void SetCursorEnd( int i ); + + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + virtual void OnMouseMoved( int x, int y, int deltaX, int deltaY ); + + virtual void SetSelectAllOnFocus( bool b ){ m_bSelectAll = b; if ( b ) OnSelectAll( this ); } + + virtual void MakeCaratVisible(); + + virtual void OnEnter(); + + virtual bool NeedsInputChars(){ return true; } + + virtual void MoveCaretToEnd(); + virtual void MoveCaretToStart(); + + Event::Caller onTextChanged; + Event::Caller onReturnPressed; + + protected: + + virtual void OnTextChanged(); + virtual bool IsTextAllowed( const Gwen::String& /*str*/, int /*iPos*/ ){ return true; } + + bool m_bSelectAll; + + int m_iCursorPos; + int m_iCursorEnd; + int m_iCursorLine; + + Gwen::Rect m_rectSelectionBounds; + Gwen::Rect m_rectCaretBounds; + + float m_fNextCaretColorChange; + Gwen::Color m_CaretColor; + }; + + class GWEN_EXPORT TextBoxNumeric : public TextBox + { + public: + + GWEN_CONTROL( TextBoxNumeric, TextBox ); + + virtual float GetFloatFromText(); + + private: + + virtual bool IsTextAllowed( const Gwen::String& str, int iPos ); + + }; + + class GWEN_EXPORT TextBoxMultiline : public TextBox + { + public: + + GWEN_CONTROL( TextBoxMultiline, TextBox ); + + virtual bool OnKeyReturn( bool bDown ); + virtual void MakeCaratVisible(); + + virtual bool OnKeyHome( bool bDown ); + virtual bool OnKeyEnd( bool bDown ); + virtual bool OnKeyUp( bool bDown ); + virtual bool OnKeyDown( bool bDown ); + + virtual int GetCurrentLine(); + + protected: + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_textboxnumeric.cpp b/lib/gwen/controls/gwen_textboxnumeric.cpp new file mode 100644 index 0000000..bd06ed7 --- /dev/null +++ b/lib/gwen/controls/gwen_textboxnumeric.cpp @@ -0,0 +1,75 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_textbox.h" +#include "../gwen_skin.h" +#include "../gwen_utility.h" +#include "../gwen_platform.h" + + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( TextBoxNumeric ) +{ + SetText( "0" ); +} + +bool TextBoxNumeric::IsTextAllowed( const Gwen::String& str, int iPos ) +{ + const String& strString = GetText().Get(); + + if ( str.length() == 0 ) + return true; + + for (size_t i=0; i 0 ) + return false; + + continue; + } + + if ( str[i] == '0' ) continue; + if ( str[i] == '1' ) continue; + if ( str[i] == '2' ) continue; + if ( str[i] == '3' ) continue; + if ( str[i] == '4' ) continue; + if ( str[i] == '5' ) continue; + if ( str[i] == '6' ) continue; + if ( str[i] == '7' ) continue; + if ( str[i] == '8' ) continue; + if ( str[i] == '9' ) continue; + + if ( str[i] == '.' ) + { + // Already a fullstop + if ( stl::count( strString.begin(), strString.end(), '.' ) > 0 ) + return false; + + continue; + } + + return false; + } + + return true; +} + +float TextBoxNumeric::GetFloatFromText() +{ + double temp = Gwen::Utility::Strings::To::Float( GetText().Get() ); + return temp; +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_toolbar.h b/lib/gwen/controls/gwen_toolbar.h new file mode 100644 index 0000000..f7b0b0d --- /dev/null +++ b/lib/gwen/controls/gwen_toolbar.h @@ -0,0 +1,63 @@ +/* + GWEN + Copyright (c) 2011 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TOOLBAR_H +#define GWEN_CONTROLS_TOOLBAR_H + +#include "../gwen_baserender.h" +#include "gwen_base.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace Controls + { + + class ToolBarButton : public Gwen::Controls::Button + { + GWEN_CONTROL_INLINE( ToolBarButton, Gwen::Controls::Button ) + { + SetSize( 20, 20 ); + Dock( Pos::Left ); + } + + virtual bool ShouldDrawBackground() + { + return IsHovered(); + } + + }; + + class ToolBarStrip : public Base + { + GWEN_CONTROL_INLINE( ToolBarStrip, Base ) + { + SetSize( 25, 25 ); + SetPadding( Padding( 2, 2, 2, 2 ) ); + } + + virtual void Render( Skin::Base* skin ) + { + skin->DrawMenuStrip( this ); + } + + virtual ToolBarButton* Add( const TextObject& Text, const TextObject& Icon ) + { + ToolBarButton* pButton = new ToolBarButton( this ); + pButton->SetToolTip( Text ); + pButton->SetImage( Icon ); + + return pButton; + } + + }; + + + } + +} +#endif diff --git a/lib/gwen/controls/gwen_treecontrol.cpp b/lib/gwen/controls/gwen_treecontrol.cpp new file mode 100644 index 0000000..e4574f0 --- /dev/null +++ b/lib/gwen/controls/gwen_treecontrol.cpp @@ -0,0 +1,75 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_treecontrol.h" +#include "gwen_scrollcontrol.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( TreeControl ) +{ + m_TreeControl = this; + + m_ToggleButton->DelayedDelete(); + m_ToggleButton = NULL; + m_Title->DelayedDelete(); + m_Title = NULL; + m_InnerPanel->DelayedDelete(); + m_InnerPanel = NULL; + + m_bAllowMultipleSelection = false; + + m_ScrollControl = new ScrollControl( this ); + m_ScrollControl->Dock( Pos::Fill ); + m_ScrollControl->SetScroll( false, true ); + m_ScrollControl->SetAutoHideBars( true ); + m_ScrollControl->SetMargin( Margin( 1, 1, 1, 1 ) ); + + m_InnerPanel = m_ScrollControl; + + m_ScrollControl->SetInnerSize( 1000, 1000 ); +} + +void TreeControl::Render( Skin::Base* skin ) +{ + if ( ShouldDrawBackground() ) + skin->DrawTreeControl( this ); +} + +void TreeControl::OnChildBoundsChanged( Gwen::Rect /*oldChildBounds*/, Base* /*pChild*/ ) +{ + m_ScrollControl->UpdateScrollBars(); + Invalidate(); +} + +void TreeControl::Clear() +{ + m_ScrollControl->Clear(); +} + +void TreeControl::Layout( Skin::Base* skin ) +{ + BaseClass::BaseClass::Layout( skin ); +} + +void TreeControl::PostLayout( Skin::Base* skin ) +{ + BaseClass::BaseClass::PostLayout( skin ); +} + +void TreeControl::OnNodeAdded( TreeNode* pNode ) +{ + pNode->onNamePress.Add( this, &TreeControl::OnNodeSelection ); +} + +void TreeControl::OnNodeSelection( Controls::Base* /*control*/ ) +{ + if ( !m_bAllowMultipleSelection || !Gwen::Input::IsKeyDown( Key::Control ) ) + DeselectAll(); +} diff --git a/lib/gwen/controls/gwen_treecontrol.h b/lib/gwen/controls/gwen_treecontrol.h new file mode 100644 index 0000000..565bb7d --- /dev/null +++ b/lib/gwen/controls/gwen_treecontrol.h @@ -0,0 +1,49 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TREECONTROL_H +#define GWEN_CONTROLS_TREECONTROL_H + +#include "gwen_base.h" +#include "gwen_treenode.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT TreeControl : public TreeNode + { + public: + + GWEN_CONTROL( TreeControl, TreeNode ); + + virtual void Render( Skin::Base* skin ); + + virtual void OnChildBoundsChanged( Gwen::Rect oldChildBounds, Base* pChild ); + + ScrollControl* Scroller() { return m_ScrollControl; } + + virtual void Clear(); + + virtual void Layout( Skin::Base* skin ); + virtual void PostLayout( Skin::Base* skin ); + + virtual void AllowMultiSelect( bool b ){ m_bAllowMultipleSelection = b; } + + virtual void OnNodeAdded( TreeNode* pNode ); + + private: + + void OnNodeSelection( Controls::Base* control ); + + ScrollControl* m_ScrollControl; + bool m_bAllowMultipleSelection; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_treenode.cpp b/lib/gwen/controls/gwen_treenode.cpp new file mode 100644 index 0000000..19f7c09 --- /dev/null +++ b/lib/gwen/controls/gwen_treenode.cpp @@ -0,0 +1,265 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_treenode.h" +#include "gwen_treecontrol.h" +#include "../gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +class OpenToggleButton : public Button +{ + GWEN_CONTROL_INLINE ( OpenToggleButton, Button ) + { + SetIsToggle( true ); + SetTabable( false ); + + } + + virtual void RenderFocus( Skin::Base* /*skin*/ ) {} + + virtual void Render( Skin::Base* skin ) + { + skin->DrawTreeButton( this, GetToggleState() ); + } +}; + +class TreeNodeText : public Button +{ + GWEN_CONTROL_INLINE ( TreeNodeText, Button ) + { + SetAlignment( Pos::Left | Pos::CenterV ); + SetShouldDrawBackground( false ); + SetHeight( 16 ); + } + + void UpdateColours() + { + if ( IsDisabled() ) return SetTextColor( GetSkin()->Colors.Button.Disabled ); + if ( IsDepressed() || GetToggleState() ) return SetTextColor( GetSkin()->Colors.Tree.Selected ); + if ( IsHovered() ) return SetTextColor( GetSkin()->Colors.Tree.Hover ); + + SetTextColor( GetSkin()->Colors.Tree.Normal ); + } +}; + +const int TreeIndentation = 14; + +GWEN_CONTROL_CONSTRUCTOR( TreeNode ) +{ + m_TreeControl = NULL; + + m_ToggleButton = new OpenToggleButton( this ); + m_ToggleButton->SetBounds( 0, 0, 15, 15 ); + m_ToggleButton->onToggle.Add( this, &TreeNode::OnToggleButtonPress ); + + m_Title = new TreeNodeText( this ); + m_Title->Dock( Pos::Top ); + m_Title->SetMargin( Margin( 16, 0, 0, 0 ) ); + m_Title->onDoubleClick.Add( this, &TreeNode::OnDoubleClickName ); + m_Title->onDown.Add( this, &TreeNode::OnClickName ); + m_Title->onRightPress.Add( this, &TreeNode::OnRightPress ); + + m_InnerPanel = new Base( this ); + m_InnerPanel->Dock( Pos::Top ); + m_InnerPanel->SetHeight( 100 ); + m_InnerPanel->SetMargin( Margin( TreeIndentation, 1, 0, 0 ) ); + m_InnerPanel->Hide(); + + m_bRoot = false; + m_bSelected = false; + m_bSelectable = true; +} + +void TreeNode::Render( Skin::Base* skin ) +{ + int iBottom = 0; + if ( m_InnerPanel->Children.size() > 0 ) + { + iBottom = m_InnerPanel->Children.back()->Y() + m_InnerPanel->Y(); + } + + skin->DrawTreeNode( this, m_InnerPanel->Visible(), IsSelected(), m_Title->Height(), m_Title->TextRight(), m_ToggleButton->Y() + m_ToggleButton->Height() * 0.5, iBottom, GetParent() == m_TreeControl ); +} + +TreeNode* TreeNode::AddNode( const TextObject& strLabel ) +{ + TreeNode* node = new TreeNode( this ); + node->SetText( strLabel ); + node->Dock( Pos::Top ); + node->SetRoot( gwen_cast( this ) != NULL ); + node->SetTreeControl( m_TreeControl ); + + if ( m_TreeControl ) + { + m_TreeControl->OnNodeAdded( node ); + } + + return node; +} + + + +void TreeNode::Layout( Skin::Base* skin ) +{ + if ( m_ToggleButton ) + { + if ( m_Title ) + { + m_ToggleButton->SetPos( 0, (m_Title->Height() - m_ToggleButton->Height()) * 0.5 ); + } + + if ( m_InnerPanel->NumChildren() == 0 ) + { + m_ToggleButton->Hide(); + m_ToggleButton->SetToggleState( false ); + m_InnerPanel->Hide(); + } + else + { + m_ToggleButton->Show(); + m_InnerPanel->SizeToChildren( false, true ); + } + } + + BaseClass::Layout( skin ); +} + +void TreeNode::PostLayout( Skin::Base* /*skin*/ ) +{ + if ( SizeToChildren( false, true ) ) + { + InvalidateParent(); + } +} + +void TreeNode::SetText( const TextObject& text ) +{ + m_Title->SetText( text ); +} + +const TextObject& TreeNode::GetText() +{ + return m_Title->GetText(); +} + +void TreeNode::SetImage( const TextObject& text ) +{ + m_Title->SetImage( text ); +} + +void TreeNode::Open() +{ + m_InnerPanel->Show(); + if ( m_ToggleButton ) m_ToggleButton->SetToggleState( true ); + Invalidate(); +} + +void TreeNode::Close() +{ + m_InnerPanel->Hide(); + if ( m_ToggleButton ) m_ToggleButton->SetToggleState( false ); + Invalidate(); +} + +void TreeNode::ExpandAll() +{ + Open(); + + Base::List& children = GetChildNodes(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + TreeNode* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + pChild->ExpandAll(); + } +} + +Button* TreeNode::GetButton(){ return m_Title; } + + +void TreeNode::OnToggleButtonPress( Base* /*control*/ ) +{ + if ( m_ToggleButton->GetToggleState() ) + { + Open(); + } + else + { + Close(); + } +} + +void TreeNode::OnDoubleClickName( Base* /*control*/ ) +{ + if ( !m_ToggleButton->Visible() ) return; + + m_ToggleButton->Toggle(); +} + +void TreeNode::OnClickName( Base* /*control*/ ) +{ + onNamePress.Call( this ); + + SetSelected( !IsSelected() ); +} + +void TreeNode::OnRightPress( Base* control ) +{ + onRightPress.Call( this ); +} + +void TreeNode::SetSelected( bool b, bool FireEvents ) +{ + if ( !m_bSelectable ) return; + if ( m_bSelected == b ) return; + + m_bSelected = b; + + if ( m_Title ) + m_Title->SetToggleState( m_bSelected ); + + if ( FireEvents ) + { + onSelectChange.Call( this ); + + if ( m_bSelected ) + { + onSelect.Call( this ); + } + else + { + onUnselect.Call( this ); + } + } + + Redraw(); +} + +void TreeNode::DeselectAll() +{ + m_bSelected = false; + + if ( m_Title ) + m_Title->SetToggleState( m_bSelected ); + + Base::List& children = GetChildNodes(); + for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) + { + TreeNode* pChild = gwen_cast(*iter); + if ( !pChild ) continue; + + pChild->DeselectAll( ); + } +} + +Controls::Base::List& TreeNode::GetChildNodes() +{ + return m_InnerPanel->GetChildren(); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_treenode.h b/lib/gwen/controls/gwen_treenode.h new file mode 100644 index 0000000..06b6fbc --- /dev/null +++ b/lib/gwen/controls/gwen_treenode.h @@ -0,0 +1,83 @@ +/* + GWEN + Copyright (c) 2011 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_TREENODE_H +#define GWEN_CONTROLS_TREENODE_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_scrollcontrol.h" + + +namespace Gwen +{ + namespace Controls + { + class TreeControl; + + class GWEN_EXPORT TreeNode : public Base + { + public: + + GWEN_CONTROL( TreeNode, Base ); + + virtual TreeNode* AddNode( const TextObject& strLabel ); + + virtual void SetText( const TextObject& text ); + virtual const TextObject& GetText(); + virtual void SetImage( const TextObject& text ); + + virtual void Open(); + virtual void Close(); + + virtual void ExpandAll(); + + virtual Button* GetButton(); + + virtual void Render( Skin::Base* skin ); + virtual void Layout( Skin::Base* skin ); + virtual void PostLayout( Skin::Base* skin ); + + virtual void SetRoot( bool b ){ m_bRoot = b; } + virtual void SetTreeControl( TreeControl* pCtrl ){ m_TreeControl = pCtrl; } + + virtual void SetSelectable( bool b ){ m_bSelectable = b; } + virtual bool IsSelected(){ return m_bSelected; } + virtual void SetSelected( bool b, bool FireEvents = true ); + + virtual void DeselectAll(); + + virtual Controls::Base::List& GetChildNodes(); + + Event::Caller onNamePress; + Event::Caller onRightPress; + Event::Caller onSelectChange; + Event::Caller onSelect; + Event::Caller onUnselect; + + + /*protected:*/ + + void OnToggleButtonPress( Base* control ); + void OnDoubleClickName( Base* control ); + void OnRightPress( Base* control ); + void OnClickName( Base* control ); + + protected: + + TreeControl* m_TreeControl; + Button* m_ToggleButton; + Button* m_Title; + + bool m_bRoot; + bool m_bSelected; + bool m_bSelectable; + }; + + } +} +#endif diff --git a/lib/gwen/controls/gwen_verticalscrollbar.cpp b/lib/gwen/controls/gwen_verticalscrollbar.cpp new file mode 100644 index 0000000..49975ae --- /dev/null +++ b/lib/gwen/controls/gwen_verticalscrollbar.cpp @@ -0,0 +1,140 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_scrollbar.h" +#include "gwen_verticalscrollbar.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +GWEN_CONTROL_CONSTRUCTOR( VerticalScrollBar ) +{ + m_Bar->SetVertical(); + + m_ScrollButton[SCROLL_BUTTON_UP]->SetDirectionUp(); + m_ScrollButton[SCROLL_BUTTON_UP]->onPress.Add( this, &VerticalScrollBar::NudgeUp ); + + m_ScrollButton[SCROLL_BUTTON_DOWN]->SetDirectionDown(); + m_ScrollButton[SCROLL_BUTTON_DOWN]->onPress.Add( this, &VerticalScrollBar::NudgeDown ); + + m_Bar->onDragged.Add( this, &VerticalScrollBar::OnBarMoved ); +} + +void VerticalScrollBar::Layout( Skin::Base* skin ) +{ + BaseClass::Layout( skin ); + + m_ScrollButton[SCROLL_BUTTON_UP]->Dock(Pos::Top); + m_ScrollButton[SCROLL_BUTTON_UP]->SetHeight( Width() ); + + m_ScrollButton[SCROLL_BUTTON_DOWN]->Dock(Pos::Bottom); + m_ScrollButton[SCROLL_BUTTON_DOWN]->SetHeight( Width() ); + + m_Bar->SetWidth( GetButtonSize() ); + //Add padding + m_Bar->SetPadding( Padding(0, GetButtonSize(), 0, GetButtonSize() ) ); + + //Calculate bar sizes + float barHeight = (m_fViewableContentSize / m_fContentSize) * (Height() - GetButtonSize()); + + if ( barHeight < GetButtonSize() * 0.5 ) + barHeight = GetButtonSize() * 0.5; + + m_Bar->SetHeight(barHeight); + m_Bar->SetHidden( Height() - (GetButtonSize() * 2) <= barHeight ); + + if ( Hidden() ) + SetScrolledAmount(0, true); + + //Based on our last scroll amount, produce a position for the bar + if ( !m_Bar->IsDepressed() ) + { + SetScrolledAmount( GetScrolledAmount(), true ); + } +} + +void VerticalScrollBar::ScrollToTop() +{ + SetScrolledAmount( 0, true ); +} +void VerticalScrollBar::ScrollToBottom() +{ + SetScrolledAmount( 1, true ); +} +void VerticalScrollBar::NudgeUp( Base* /*control*/ ) +{ + if ( !IsDisabled() ) + SetScrolledAmount(GetScrolledAmount() - GetNudgeAmount(), true); +} + +void VerticalScrollBar::NudgeDown( Base* /*control*/ ) +{ + if ( !IsDisabled() ) + SetScrolledAmount(GetScrolledAmount() + GetNudgeAmount(), true); +} + +float VerticalScrollBar::GetNudgeAmount() +{ + if ( m_bDepressed ) + return m_fViewableContentSize / m_fContentSize; + else + return BaseClass::GetNudgeAmount(); +} + +void VerticalScrollBar::OnMouseClickLeft( int x, int y, bool bDown ) +{ + if ( bDown ) + { + m_bDepressed = true; + Gwen::MouseFocus = this; + } + else + { + Gwen::Point clickPos = CanvasPosToLocal( Gwen::Point( x, y ) ); + if ( clickPos.y < m_Bar->Y() ) + NudgeUp( this ); + else if ( clickPos.y > m_Bar->Y() + m_Bar->Height() ) + NudgeDown( this ); + + m_bDepressed = false; + Gwen::MouseFocus = NULL; + } +} + +float VerticalScrollBar::CalculateScrolledAmount() +{ + return (float)(m_Bar->Y() - GetButtonSize()) / (float)(Height() - m_Bar->Height() - (GetButtonSize() * 2 )); +} + +bool VerticalScrollBar::SetScrolledAmount(float amount, bool forceUpdate) +{ + amount = Gwen::Clamp( amount, 0, 1 ); + + if ( !BaseClass::SetScrolledAmount( amount, forceUpdate ) ) + return false; + + if ( forceUpdate ) + { + int newY = GetButtonSize() + (amount * ((Height() - m_Bar->Height()) - (GetButtonSize()*2))); + m_Bar->MoveTo( m_Bar->X(), newY); + } + + return true; +} + +void VerticalScrollBar::OnBarMoved( Controls::Base* control ) +{ + if ( m_Bar->IsDepressed() ) + { + SetScrolledAmount( CalculateScrolledAmount(), false ); + BaseClass::OnBarMoved(control); + } + else + { + InvalidateParent(); + } +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_verticalscrollbar.h b/lib/gwen/controls/gwen_verticalscrollbar.h new file mode 100644 index 0000000..bc7c4fd --- /dev/null +++ b/lib/gwen/controls/gwen_verticalscrollbar.h @@ -0,0 +1,47 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_VERTICALSCROLLBAR_H +#define GWEN_CONTROLS_VERTICALSCROLLBAR_H +#include "gwen_base.h" +#include "gwen_scrollbar.h" +#include "../gwen.h" +#include "../gwen_skin.h" + +namespace Gwen +{ + namespace Controls + { + + class GWEN_EXPORT VerticalScrollBar : public BaseScrollBar + { + + GWEN_CONTROL( VerticalScrollBar, BaseScrollBar ); + + virtual void Layout( Skin::Base* skin ); + + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + virtual void OnBarMoved( Controls::Base* control ); + + virtual int GetBarSize() { return m_Bar->Height(); } + virtual int GetBarPos() { return m_Bar->Y() - Width(); } + virtual void SetBarSize( int size ) { m_Bar->SetHeight( size ); } + virtual int GetButtonSize() { return Width(); } + + virtual void ScrollToTop(); + virtual void ScrollToBottom(); + virtual void NudgeUp( Base* control ); + virtual void NudgeDown( Base* control ); + virtual float GetNudgeAmount(); + + virtual float CalculateScrolledAmount(); + virtual bool SetScrolledAmount(float amount, bool forceUpdate); + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_verticalslider.cpp b/lib/gwen/controls/gwen_verticalslider.cpp new file mode 100644 index 0000000..e48a583 --- /dev/null +++ b/lib/gwen/controls/gwen_verticalslider.cpp @@ -0,0 +1,49 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_slider.h" +#include "gwen_verticalslider.h" + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( VerticalSlider ) +{ + m_SliderBar->SetHorizontal( false ); +} + +float VerticalSlider::CalculateValue() +{ + return 1 - (float)m_SliderBar->Y() / (float)( Height() - m_SliderBar->Height() ); +} + +void VerticalSlider::UpdateBarFromValue() +{ + m_SliderBar->MoveTo( m_SliderBar->X(), ( Height() - m_SliderBar->Height() ) * ( 1 - m_fValue )); +} + + +void VerticalSlider::OnMouseClickLeft( int x, int y, bool bDown ) +{ + m_SliderBar->MoveTo( m_SliderBar->X(), CanvasPosToLocal( Gwen::Point( x, y ) ).y - m_SliderBar->Height() * 0.5 ); + m_SliderBar->OnMouseClickLeft( x, y, bDown ); + OnMoved( m_SliderBar ); +} + + +void VerticalSlider::Layout(Skin::Base* /*skin*/) +{ + m_SliderBar->SetSize( Width(), 15 ); +} + + +void VerticalSlider::Render( Skin::Base* skin ) +{ + skin->DrawSlider( this, false, m_bClampToNotches ? m_iNumNotches : 0, m_SliderBar->Height() ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_verticalslider.h b/lib/gwen/controls/gwen_verticalslider.h new file mode 100644 index 0000000..6bc9d2f --- /dev/null +++ b/lib/gwen/controls/gwen_verticalslider.h @@ -0,0 +1,37 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_VERTICALSLIDER_H +#define GWEN_CONTROLS_VERTICALSLIDER_H + +#include "gwen_base.h" +#include "gwen_button.h" +#include "gwen_dragger.h" +#include "../gwen.h" +#include "../gwen_skin.h" +#include "gwen_slider.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT VerticalSlider : public Slider + { + GWEN_CONTROL( VerticalSlider, Slider ); + + virtual void Layout( Skin::Base* skin ); + virtual void Render( Skin::Base* skin ); + + virtual float CalculateValue(); + virtual void UpdateBarFromValue(); + virtual void OnMouseClickLeft( int x, int y, bool bDown ); + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_windowbuttons.h b/lib/gwen/controls/gwen_windowbuttons.h new file mode 100644 index 0000000..b1c6531 --- /dev/null +++ b/lib/gwen/controls/gwen_windowbuttons.h @@ -0,0 +1,80 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_WINDOWS_BUTTONS_H +#define GWEN_CONTROLS_WINDOWS_BUTTONS_H + +#include "../gwen.h" +#include "gwen_button.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT WindowCloseButton : public Button + { + GWEN_CONTROL_INLINE( WindowCloseButton, Button ) + { + m_pWindow = NULL; + SetSize( 31, 31 ); + SetText( "" ); + } + + virtual void Render( Skin::Base* skin ) + { + if ( !m_pWindow ) return; + + skin->DrawWindowCloseButton( this, IsDepressed() && IsHovered(), IsHovered() && ShouldDrawHover(), IsDisabled() ); + } + + void SetWindow( Gwen::Controls::Base* p ) + { + m_pWindow = p; + } + + protected: + + Controls::Base* m_pWindow; + }; + + class GWEN_EXPORT WindowMaximizeButton : public WindowCloseButton + { + GWEN_CONTROL_INLINE( WindowMaximizeButton, WindowCloseButton ){ m_bMaximized = false; }; + + virtual void Render( Skin::Base* skin ) + { + if ( !m_pWindow ) return; + skin->DrawWindowMaximizeButton( this, IsDepressed() && IsHovered(), IsHovered() && ShouldDrawHover(), IsDisabled(), m_bMaximized ); + } + + virtual void SetMaximized( bool b ) + { + m_bMaximized = b; + } + + protected: + + bool m_bMaximized; + }; + + class GWEN_EXPORT WindowMinimizeButton : public WindowCloseButton + { + GWEN_CONTROL_INLINE( WindowMinimizeButton, WindowCloseButton ){}; + + virtual void Render( Skin::Base* skin ) + { + if ( !m_pWindow ) return; + skin->DrawWindowMinimizeButton( this, IsDepressed() && IsHovered(), IsHovered() && ShouldDrawHover(), IsDisabled() ); + } + + }; + } +} + +#endif diff --git a/lib/gwen/controls/gwen_windowcanvas.cpp b/lib/gwen/controls/gwen_windowcanvas.cpp new file mode 100644 index 0000000..9191801 --- /dev/null +++ b/lib/gwen/controls/gwen_windowcanvas.cpp @@ -0,0 +1,331 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "../gwen.h" +#include "gwen_windowcanvas.h" +#include "../gwen_skin.h" +#include "gwen_menu.h" +#include "../gwen_draganddrop.h" +#include "../gwen_tooltip.h" + +#ifndef GWEN_NO_ANIMATION +#include "../gwen_anim.h" +#endif + +using namespace Gwen; +using namespace Gwen::Controls; + +WindowCanvas::WindowCanvas( int x, int y, int w, int h, Gwen::Skin::Base* pSkin, const Gwen::String& strWindowTitle ) : BaseClass( NULL ) +{ + m_bQuit = false; + m_bCanMaximize = true; + m_bIsMaximized = false; + + SetPadding( Padding( 1, 0, 1, 1 ) ); + + // Centering the window on the desktop + { + int dw, dh; + Gwen::Platform::GetDesktopSize( dw, dh ); + + if ( x < 0 ) x = (dw - w) * 0.5; + if ( y < 0 ) y = (dh - h) * 0.5; + } + + m_pOSWindow = Gwen::Platform::CreatePlatformWindow( x, y, w, h, strWindowTitle ); + m_WindowPos = Gwen::Point( x, y ); + + pSkin->GetRender()->InitializeContext( this ); + pSkin->GetRender()->Init(); + m_pSkinChange = pSkin; + + SetSize( w, h ); + + m_TitleBar = new Gwen::ControlsInternal::Dragger( this ); + m_TitleBar->SetHeight( 24 ); + m_TitleBar->SetPadding( Padding( 0, 0, 0, 0 ) ); + m_TitleBar->SetMargin( Margin( 0, 0, 0, 0 ) ); + m_TitleBar->Dock( Pos::Top ); + m_TitleBar->SetDoMove( false ); + m_TitleBar->onDragged.Add( this, &ThisClass::Dragger_Moved ); + m_TitleBar->onDragStart.Add( this, &ThisClass::Dragger_Start ); + m_TitleBar->onDoubleClickLeft.Add( this, &ThisClass::OnTitleDoubleClicked ); + + m_Title = new Gwen::Controls::Label( m_TitleBar ); + m_Title->SetAlignment( Pos::Left | Pos::CenterV ); + m_Title->SetText( strWindowTitle ); + m_Title->Dock( Pos::Fill ); + m_Title->SetPadding( Padding( 8, 0, 0, 0 ) ); + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleInactive ); + + // CLOSE + { + m_pClose = new Gwen::Controls::WindowCloseButton( m_TitleBar, "Close" ); + m_pClose->Dock( Pos::Right ); + m_pClose->SetMargin( Margin( 0, 0, 4, 0 ) ); + m_pClose->onPress.Add( this, &WindowCanvas::CloseButtonPressed ); + m_pClose->SetTabable( false ); + m_pClose->SetWindow( this ); + } + + // MAXIMIZE + { + m_pMaximize = new Gwen::Controls::WindowMaximizeButton( m_TitleBar, "Maximize" ); + m_pMaximize->Dock( Pos::Right ); + m_pMaximize->onPress.Add( this, &WindowCanvas::MaximizeButtonPressed ); + m_pMaximize->SetTabable( false ); + m_pMaximize->SetWindow( this ); + } + + // MINIMiZE + { + m_pMinimize = new Gwen::Controls::WindowMinimizeButton( m_TitleBar, "Minimize" ); + m_pMinimize->Dock( Pos::Right ); + m_pMinimize->onPress.Add( this, &WindowCanvas::MinimizeButtonPressed ); + m_pMinimize->SetTabable( false ); + m_pMinimize->SetWindow( this ); + } + + // Bottom Right Corner Sizer + { + m_Sizer = new Gwen::ControlsInternal::Dragger( this ); + m_Sizer->SetSize( 16, 16 ); + m_Sizer->SetDoMove( false ); + m_Sizer->onDragged.Add( this, &WindowCanvas::Sizer_Moved ); + m_Sizer->onDragStart.Add( this, &WindowCanvas::Dragger_Start ); + m_Sizer->SetCursor( Gwen::CursorType::SizeNWSE ); + } +} + +WindowCanvas::~WindowCanvas() +{ + DestroyWindow(); +} + +void* WindowCanvas::GetWindow() +{ + return m_pOSWindow; +} + +void WindowCanvas::Layout( Skin::Base* skin ) +{ + m_Sizer->BringToFront(); + m_Sizer->Position( Pos::Right | Pos::Bottom ); + + BaseClass::Layout( skin ); +} + +void WindowCanvas::DoThink() +{ + Platform::MessagePump( m_pOSWindow, this ); + BaseClass::DoThink(); + RenderCanvas(); +} + +void WindowCanvas::RenderCanvas() +{ + // + // If there isn't anything going on we sleep the thread for a few ms + // This gives some cpu time back to the os. If you're using a rendering + // method that needs continual updates, just call canvas->redraw every frame. + // + if ( !NeedsRedraw() ) + { + Platform::Sleep( 10 ); + return; + } + + m_bNeedsRedraw = false; + + Gwen::Renderer::Base* render = m_Skin->GetRender(); + + if ( render->BeginContext( this ) ) + { + render->Begin(); + + RecurseLayout( m_Skin ); + + render->SetClipRegion( GetRenderBounds() ); + render->SetRenderOffset( Gwen::Point( X() * -1, Y() * -1 ) ); + render->SetScale( Scale() ); + + if ( m_bDrawBackground ) + { + render->SetDrawColor( m_BackgroundColor ); + render->DrawFilledRect( GetRenderBounds() ); + } + + DoRender( m_Skin ); + + DragAndDrop::RenderOverlay( this, m_Skin ); + + ToolTip::RenderToolTip( m_Skin ); + + render->End(); + } + + render->EndContext( this ); + + render->PresentContext( this ); +} + +void WindowCanvas::Render( Skin::Base* skin ) +{ + bool bHasFocus = IsOnTop(); + + if ( bHasFocus ) + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleActive ); + else + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleInactive ); + + skin->DrawWindow( this, m_TitleBar->Bottom(), bHasFocus ); +} + + +void WindowCanvas::DestroyWindow() +{ + if ( m_pOSWindow ) + { + GetSkin()->GetRender()->ShutdownContext( this ); + Gwen::Platform::DestroyPlatformWindow( m_pOSWindow ); + m_pOSWindow = NULL; + } +} + +bool WindowCanvas::InputQuit() +{ + m_bQuit = true; + return true; +} + +Skin::Base* WindowCanvas::GetSkin( void ) +{ + if ( m_pSkinChange ) + { + SetSkin( m_pSkinChange ); + m_pSkinChange = NULL; + } + + return BaseClass::GetSkin(); +} + + +void WindowCanvas::Dragger_Start() +{ + Gwen::Platform::GetCursorPos( m_HoldPos ); + + m_HoldPos.x -= m_WindowPos.x; + m_HoldPos.y -= m_WindowPos.y; +} + +void WindowCanvas::Dragger_Moved() +{ + Gwen::Point p; + Gwen::Platform::GetCursorPos( p ); + + // + // Dragged out of maximized + // + if ( m_bIsMaximized ) + { + float fOldWidth = Width(); + + SetMaximize( false ); + + // Change the hold pos to be the same distance across the titlebar of the resized window + m_HoldPos.x = ((float)m_HoldPos.x) * ( (float)Width() / fOldWidth ); + m_HoldPos.y = 10; + } + + SetPos( p.x - m_HoldPos.x, p.y - m_HoldPos.y ); +} + +void WindowCanvas::SetPos( int x, int y ) +{ + int w, h; + Gwen::Platform::GetDesktopSize( w, h ); + y = Gwen::Clamp( y, 0, h ); + + m_WindowPos.x = x; + m_WindowPos.y = y; + + Gwen::Platform::SetBoundsPlatformWindow( m_pOSWindow, x, y, Width(), Height() ); +} + +void WindowCanvas::CloseButtonPressed() +{ + InputQuit(); +} + +bool WindowCanvas::IsOnTop() +{ + return Gwen::Platform::HasFocusPlatformWindow( m_pOSWindow ); +} + + +void WindowCanvas::Sizer_Moved() +{ + Gwen::Point p; + Gwen::Platform::GetCursorPos( p ); + + int w = (p.x) - m_WindowPos.x; + int h = (p.y) - m_WindowPos.y; + + w = Clamp( w, 100, 9999 ); + h = Clamp( h, 100, 9999 ); + + Gwen::Platform::SetBoundsPlatformWindow( m_pOSWindow, m_WindowPos.x, m_WindowPos.y, w, h ); + GetSkin()->GetRender()->ResizedContext( this, w, h ); + this->SetSize( w, h ); + + BaseClass::DoThink(); + RenderCanvas(); +} + +void WindowCanvas::OnTitleDoubleClicked() +{ + if ( !CanMaximize() ) return; + + SetMaximize( !m_bIsMaximized ); +} + +void WindowCanvas::SetMaximize( bool b ) +{ + m_bIsMaximized = b; + m_pMaximize->SetMaximized( m_bIsMaximized ); + + Gwen::Point pSize, pPos; + + Gwen::Platform::SetWindowMaximized( m_pOSWindow, m_bIsMaximized, pPos, pSize ); + SetSize( pSize.x, pSize.y ); + m_WindowPos = pPos; + + GetSkin()->GetRender()->ResizedContext( this, pSize.x, pSize.y ); + + BaseClass::DoThink(); + RenderCanvas(); +} + +void WindowCanvas::MaximizeButtonPressed() +{ + if ( !CanMaximize() ) return; + + SetMaximize( !m_bIsMaximized ); +} + +void WindowCanvas::MinimizeButtonPressed() +{ + Gwen::Platform::SetWindowMinimized( m_pOSWindow, true ); +} + +void WindowCanvas::SetCanMaximize( bool b ) +{ + if ( m_bCanMaximize == b ) return; + + m_bCanMaximize = b; + m_pMaximize->SetDisabled( !b ); +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_windowcanvas.h b/lib/gwen/controls/gwen_windowcanvas.h new file mode 100644 index 0000000..c0fae4a --- /dev/null +++ b/lib/gwen/controls/gwen_windowcanvas.h @@ -0,0 +1,93 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_WINDOWCANVAS_H +#define GWEN_CONTROLS_WINDOWCANVAS_H + +#include "gwen_base.h" +#include "../gwen_inputhandler.h" +#include "../gwen_windowprovider.h" +#include "gwen_dragger.h" +#include "gwen_label.h" +#include "gwen_windowbuttons.h" + +namespace Gwen +{ + namespace Controls + { + class GWEN_EXPORT WindowCanvas : public Canvas, public Gwen::WindowProvider + { + public: + + GWEN_CLASS( WindowCanvas, Controls::Canvas ); + + WindowCanvas( int x, int y, int w, int h, Gwen::Skin::Base* pRenderer, const Gwen::String& strWindowTitle = "" ); + ~WindowCanvas(); + + virtual void DoThink(); + + virtual bool WantsQuit(){ return m_bQuit; } + + // Gwen::WindowProvider + virtual void* GetWindow(); + + virtual bool InputQuit(); + + Skin::Base* GetSkin( void ); + + virtual void Render( Skin::Base* skin ); + + virtual void SetPos( int x, int y ); + virtual bool IsOnTop(); + + virtual void Layout( Skin::Base* skin ); + + virtual bool CanMaximize(){ return m_bCanMaximize; } + virtual void SetCanMaximize( bool b ); + virtual void SetMaximize( bool b ); + + virtual void SetSizable( bool b ){ m_Sizer->SetHidden( !b ); } + virtual bool GetSizable(){ return m_Sizer->Visible(); } + + protected: + + virtual void RenderCanvas(); + virtual void DestroyWindow(); + + virtual void CloseButtonPressed(); + virtual void MaximizeButtonPressed(); + virtual void MinimizeButtonPressed(); + + virtual void Dragger_Start(); + virtual void Dragger_Moved(); + virtual void Sizer_Moved(); + virtual void OnTitleDoubleClicked(); + + void* m_pOSWindow; + bool m_bQuit; + + Gwen::Skin::Base* m_pSkinChange; + + ControlsInternal::Dragger* m_TitleBar; + ControlsInternal::Dragger* m_Sizer; + Gwen::Controls::Label* m_Title; + + + Gwen::Point m_WindowPos; + Gwen::Point m_HoldPos; + + bool m_bCanMaximize; + bool m_bIsMaximized; + + Gwen::Controls::WindowCloseButton* m_pClose; + Gwen::Controls::WindowMaximizeButton* m_pMaximize; + Gwen::Controls::WindowMinimizeButton* m_pMinimize; + + }; + } +} +#endif diff --git a/lib/gwen/controls/gwen_windowcontrol.cpp b/lib/gwen/controls/gwen_windowcontrol.cpp new file mode 100644 index 0000000..9c9d077 --- /dev/null +++ b/lib/gwen/controls/gwen_windowcontrol.cpp @@ -0,0 +1,167 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_windowcontrol.h" +#include "gwen_imagepanel.h" +#include "gwen_label.h" +#include "gwen_modal.h" + + +using namespace Gwen; +using namespace Gwen::Controls; +using namespace Gwen::ControlsInternal; + + +GWEN_CONTROL_CONSTRUCTOR( WindowControl ) +{ + m_Modal = NULL; + m_bDeleteOnClose = false; + + m_TitleBar = new Dragger( this ); + m_TitleBar->SetHeight( 24 ); + m_TitleBar->SetPadding( Padding( 0, 0, 0, 0 ) ); + m_TitleBar->SetMargin( Margin( 0, 0, 0, 4 ) ); + m_TitleBar->SetTarget( this ); + m_TitleBar->Dock( Pos::Top ); + + m_Title = new Label( m_TitleBar ); + m_Title->SetAlignment( Pos::Left | Pos::CenterV ); + m_Title->SetText( "Window" ); + m_Title->Dock( Pos::Fill ); + m_Title->SetPadding( Padding( 8, 0, 0, 0 ) ); + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleInactive ); + + m_CloseButton = new Gwen::Controls::WindowCloseButton( m_TitleBar ); + m_CloseButton->SetText( "" ); + m_CloseButton->Dock( Pos::Right ); + m_CloseButton->onPress.Add( this, &WindowControl::CloseButtonPressed ); + m_CloseButton->SetTabable( false ); + m_CloseButton->SetName( "closeButton" ); + m_CloseButton->SetWindow( this ); + + //Create a blank content control, dock it to the top - Should this be a ScrollControl? + m_InnerPanel = new Base( this ); + m_InnerPanel->Dock( Pos::Fill ); + + GetResizer( 8 )->Hide(); + + BringToFront(); + + SetTabable( false ); + Focus(); + + SetMinimumSize( Gwen::Point( 100, 40 ) ); + SetClampMovement( true ); + SetKeyboardInputEnabled( false ); +} + + +WindowControl::~WindowControl() +{ + DestroyModal(); +} + +void WindowControl::MakeModal( bool bDrawBackground ) +{ + if ( m_Modal ) return; + + m_Modal = new ControlsInternal::Modal( GetCanvas() ); + SetParent( m_Modal ); + + m_Modal->SetShouldDrawBackground( bDrawBackground ); +} + +void WindowControl::DestroyModal() +{ + if ( !m_Modal ) return; + + // Really should be restoring our parent here.. but we don't know who it is. + // Assume it's the canvas. + SetParent( GetCanvas() ); + + m_Modal->DelayedDelete(); + m_Modal = NULL; +} + +bool WindowControl::IsOnTop() +{ + for (Base::List::reverse_iterator iter = GetParent()->Children.rbegin(); iter != GetParent()->Children.rend(); ++iter) + { + WindowControl* pWindow = gwen_cast(*iter); + + if ( !pWindow ) + continue; + + if ( pWindow == this ) + return true; + + return false; + } + + return false; + +} + +void WindowControl::Render( Skin::Base* skin ) +{ + bool bHasFocus = IsOnTop(); + + if ( bHasFocus ) + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleActive ); + else + m_Title->SetTextColor( GetSkin()->Colors.Window.TitleInactive ); + + skin->DrawWindow( this, m_TitleBar->Bottom(), bHasFocus ); +} + +void WindowControl::RenderUnder( Skin::Base* skin ) +{ + BaseClass::RenderUnder( skin ); + skin->DrawShadow( this ); +} + +void WindowControl::SetTitle(Gwen::String title) +{ + m_Title->SetText( title ); +} + +void WindowControl::SetClosable( bool closeable ) +{ + m_CloseButton->SetHidden( !closeable ); +} + +void WindowControl::SetHidden( bool hidden ) +{ + if ( !hidden ) + BringToFront(); + + BaseClass::SetHidden(hidden); +} + +void WindowControl::Touch() +{ + BaseClass::Touch(); + BringToFront(); +} + +void WindowControl::CloseButtonPressed() +{ + DestroyModal(); + + onWindowClosed.Call( this ); + + SetHidden( true ); + + if ( m_bDeleteOnClose ) + DelayedDelete(); +} + + +void WindowControl::RenderFocus( Gwen::Skin::Base* /*skin*/ ) +{ + +} \ No newline at end of file diff --git a/lib/gwen/controls/gwen_windowcontrol.h b/lib/gwen/controls/gwen_windowcontrol.h new file mode 100644 index 0000000..dd26353 --- /dev/null +++ b/lib/gwen/controls/gwen_windowcontrol.h @@ -0,0 +1,68 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_WINDOWCONTROL_H +#define GWEN_CONTROLS_WINDOWCONTROL_H + +#include "../gwen.h" +#include "gwen_base.h" +#include "gwen_label.h" +#include "gwen_button.h" +#include "gwen_dragger.h" +#include "gwen_label.h" +#include "gwen_resizablecontrol.h" +#include "gwen_modal.h" +#include "gwen_windowbuttons.h" +#include "../gwen_skin.h" + + +namespace Gwen +{ + namespace Controls + { + class CloseButton; + + class GWEN_EXPORT WindowControl : public ResizableControl + { + public: + + GWEN_CONTROL( WindowControl, ResizableControl ); + + virtual ~WindowControl(); + virtual void Render( Skin::Base* skin ); + virtual void RenderUnder( Skin::Base* skin ); + + virtual void SetTitle( Gwen::String title ); + virtual void SetClosable(bool closeable); + + virtual void Touch(); + bool IsOnTop(); + + virtual void SetHidden(bool hidden); + + void CloseButtonPressed(); + void RenderFocus( Gwen::Skin::Base* skin ); + void SetDeleteOnClose( bool b ){ m_bDeleteOnClose = b; } + + void MakeModal( bool bDrawBackground = true ); + void DestroyModal(); + + Gwen::Event::Caller onWindowClosed; + + protected: + + Gwen::ControlsInternal::Dragger* m_TitleBar; + Gwen::Controls::Label* m_Title; + Gwen::Controls::WindowCloseButton* m_CloseButton; + + bool m_bDeleteOnClose; + + ControlsInternal::Modal* m_Modal; + }; + } +} +#endif diff --git a/lib/gwen/controls/layout/gwen_position.h b/lib/gwen/controls/layout/gwen_position.h new file mode 100644 index 0000000..26bdcbf --- /dev/null +++ b/lib/gwen/controls/layout/gwen_position.h @@ -0,0 +1,66 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LAYOUT_POSITION_H +#define GWEN_CONTROLS_LAYOUT_POSITION_H + +#include "../gwen_label.h" +#include "../../gwen_utility.h" + + +namespace Gwen +{ + namespace Controls + { + namespace Layout + { + class GWEN_EXPORT Position : public Base + { + public: + + GWEN_CONTROL_INLINE( Position, Base ) + { + SetPosition( Pos::Left | Pos::Top ); + } + + void PostLayout( Skin::Base* skin ) + { + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + Base* pChild = *it; + + if ( pChild->GetDock() != Pos::None ) continue; + + pChild->Position( m_iPosition ); + + } + } + + void SetPosition( int p ) + { + if ( m_iPosition == p ) return; + + m_iPosition = p; + Invalidate(); + } + + private: + + int m_iPosition; + }; + + class GWEN_EXPORT Center : public Position + { + GWEN_CONTROL_INLINE( Center, Position ) + { + SetPosition( Pos::Center ); + } + }; + } + } +} +#endif diff --git a/lib/gwen/controls/layout/gwen_table.h b/lib/gwen/controls/layout/gwen_table.h new file mode 100644 index 0000000..8b527cf --- /dev/null +++ b/lib/gwen/controls/layout/gwen_table.h @@ -0,0 +1,328 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LAYOUT_TABLE_H +#define GWEN_CONTROLS_LAYOUT_TABLE_H + +#include "../gwen_button.h" +#include "../../gwen_utility.h" + +namespace Gwen +{ + namespace Controls + { + namespace Layout + { + class Table; + + class GWEN_EXPORT TableRow : public Base + { + static const int MaxColumns = 16; + + GWEN_CONTROL_INLINE( TableRow, Base ) + { + SetEven( false ); + + for ( int i=0; i= MaxColumns ) + m_ColumnCount = MaxColumns; + + for ( int i=0; iDock( Pos::Left ); + m_Columns[i]->SetPadding( Padding( 3, 3, 3, 3 ) ); + } + } + else if ( m_Columns[i] ) + { + m_Columns[i]->DelayedDelete(); + m_Columns[i] = NULL; + } + + m_ColumnCount = iCount; + } + } + + void SetColumnWidth( int i, int iWidth ) + { + if ( !m_Columns[i] ) return; + if ( m_Columns[i]->Width() == iWidth ) return; + + m_Columns[i]->SetWidth( iWidth ); + } + + void SetCellText( int i, const TextObject& strString ) + { + if ( !m_Columns[i] ) return; + m_Columns[i]->SetText( strString ); + } + + void SetCellContents( int i, Base* pControl, bool bEnableMouseInput = false ) + { + if ( !m_Columns[i] ) return; + pControl->SetParent( m_Columns[i] ); + + m_Columns[i]->SetMouseInputEnabled( bEnableMouseInput ); + } + + Label* GetCellContents( int i ) + { + return m_Columns[i]; + } + + void SizeToContents() + { + int iHeight = 0; + + for ( int i=0; iNumChildren() > 1 ) + { + m_Columns[i]->SizeToChildren(); + } + else + { + m_Columns[i]->SizeToContents(); + } + + iHeight = Utility::Max( iHeight, m_Columns[i]->Height() ); + } + + SetHeight( iHeight ); + } + + void SetTextColor( const Gwen::Color& color ) + { + for ( int i=0; iSetTextColor( color ); + } + } + + //You might hate this. Actually I know you will + virtual const TextObject& GetText( int i ) + { + return m_Columns[i]->GetText(); + } + virtual void SetSelected( bool /*b*/ ) {} + + // + // This is sometimes called by derivatives. + // + Gwen::Event::Caller onRowSelected; + + virtual bool GetEven(){ return m_bEvenRow; } + virtual void SetEven( bool b ) { m_bEvenRow = b; } + + private: + + bool m_bEvenRow; + int m_ColumnCount; + Label* m_Columns[MaxColumns]; + + friend class Table; + + + }; + + class GWEN_EXPORT Table : public Base + { + public: + + GWEN_CONTROL_INLINE( Table, Base ) + { + m_iColumnCount = 1; + m_iDefaultRowHeight = 22; + + for (int i=0; i(*it); + if ( !pRow ) continue; + + pRow->SetColumnCount( i ); + } + + m_iColumnCount = i; + } + + void SetColumnWidth( int i, int iWidth ) + { + if ( m_ColumnWidth[i] == iWidth ) return; + + m_ColumnWidth[i] = iWidth; + Invalidate(); + } + + TableRow* AddRow() + { + TableRow* row = new TableRow( this ); + AddRow( row ); + return row; + } + + void AddRow( TableRow* pRow ) + { + pRow->SetParent( this ); + pRow->SetColumnCount( m_iColumnCount ); + pRow->SetHeight( m_iDefaultRowHeight ); + pRow->Dock( Pos::Top ); + + Invalidate(); + } + + TableRow* GetRow( int i ) + { + return gwen_cast( GetChild( i ) ); + } + + unsigned int RowCount( int i ) + { + return NumChildren(); + } + + void Remove( TableRow* pRow ) + { + pRow->DelayedDelete(); + } + + void Clear() + { + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + TableRow* pRow = gwen_cast(*it); + if ( !pRow ) continue; + Remove( pRow ); + } + } + + void Layout( Skin::Base* skin ) + { + BaseClass::Layout( skin ); + + if ( m_bSizeToContents ) + { + DoSizeToContents(); + } + + int iSizeRemainder = Width(); + int iAutoSizeColumns = 0; + + for (int i=0; i 1 ) iSizeRemainder /= iAutoSizeColumns; + + bool bEven = false; + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + TableRow* pRow = gwen_cast(*it); + if ( !pRow ) continue; + + pRow->SizeToContents(); + pRow->SetEven( bEven ); + bEven = !bEven; + + for (int i=0; iSetColumnWidth( i, iSizeRemainder ); + else + pRow->SetColumnWidth( i, m_ColumnWidth[i] ); + } + } + + InvalidateParent(); + } + + void PostLayout( Skin::Base* /*skin*/ ) + { + if ( m_bSizeToContents ) + { + SizeToChildren(); + m_bSizeToContents = false; + } + } + + void SizeToContents() + { + m_bSizeToContents = true; + Invalidate(); + } + + void DoSizeToContents() + { + for (int i=0; i(*it); + if ( !pRow ) continue; + + pRow->SizeToContents(); + + for (int i=0; im_Columns[i] ) + { + m_ColumnWidth[i] = Utility::Max( m_ColumnWidth[i], pRow->m_Columns[i]->Width() ); + } + } + //iBottom += pRow->Height(); + } + + InvalidateParent(); + } + + private: + + bool m_bSizeToContents; + int m_iColumnCount; + int m_iDefaultRowHeight; + + int m_ColumnWidth[ TableRow::MaxColumns ]; + }; + } + } +} +#endif diff --git a/lib/gwen/controls/layout/gwen_tile.h b/lib/gwen/controls/layout/gwen_tile.h new file mode 100644 index 0000000..ac4b398 --- /dev/null +++ b/lib/gwen/controls/layout/gwen_tile.h @@ -0,0 +1,65 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_LAYOUT_TILE_H +#define GWEN_CONTROLS_LAYOUT_TILE_H + +#include "../gwen_base.h" + +namespace Gwen +{ + namespace Controls + { + namespace Layout + { + class GWEN_EXPORT Tile : public Base + { + public: + + GWEN_CONTROL_INLINE( Tile, Base ) + { + Dock( Pos::Fill ); + SetTileSize( 22, 22 ); + } + + void PostLayout( Skin::Base* skin ) + { + Gwen::Rect bounds = GetInnerBounds(); + Gwen::Point pos = Point( bounds.x, bounds.y ); + + for ( Base::List::iterator it = Children.begin(); it != Children.end(); ++it ) + { + Base* pChild = *it; + if ( pChild->GetDock() != Pos::None ) continue; + + pChild->SetPos( pos.x + (m_TileSize.x/2) - (pChild->Width()/2), pos.y + (m_TileSize.y/2) - (pChild->Height()/2) ); + + pos.x = pos.x + m_TileSize.x; + if ( pos.x + m_TileSize.x > bounds.x + bounds.w ) + { + pos.x = bounds.x; + pos.y += m_TileSize.y; + } + + } + } + + void SetTileSize( int x, int y ) + { + m_TileSize = Point( x, y ); + } + + private: + + Point m_TileSize; + }; + + } + } +} + +#endif diff --git a/lib/gwen/controls/property/gwen_baseproperty.h b/lib/gwen/controls/property/gwen_baseproperty.h new file mode 100644 index 0000000..24cbcd2 --- /dev/null +++ b/lib/gwen/controls/property/gwen_baseproperty.h @@ -0,0 +1,56 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTY_BASEPROPERTY_H +#define GWEN_CONTROLS_PROPERTY_BASEPROPERTY_H + +#include "../gwen_base.h" +#include "../../gwen.h" +#include "../../gwen_skin.h" +#include "../../gwen_utility.h" + + +namespace Gwen +{ + namespace Controls + { + namespace Property + { + class GWEN_EXPORT Base : public Gwen::Controls::Base + { + public: + + GWEN_CONTROL_INLINE( Base, Gwen::Controls::Base ) + { + SetHeight( 17 ); + } + + virtual TextObject GetPropertyValue() = 0; + + virtual void SetPropertyValue( const TextObject& v, bool bFireChangeEvents = false ) = 0; + + virtual bool IsEditing() = 0; + + virtual void DoChanged() + { + Event::Information info; + info.String = GetPropertyValue(); + + onChange.Call( this, info ); + } + + void OnPropertyValueChanged( Gwen::Controls::Base* /*control*/ ) + { + DoChanged(); + } + + Event::Caller onChange; + }; + } + } +} +#endif diff --git a/lib/gwen/controls/property/gwen_checkbox.h b/lib/gwen/controls/property/gwen_checkbox.h new file mode 100644 index 0000000..fff7c46 --- /dev/null +++ b/lib/gwen/controls/property/gwen_checkbox.h @@ -0,0 +1,64 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTY_CHECKBOX_H +#define GWEN_CONTROLS_PROPERTY_CHECKBOX_H + +#include "gwen_baseproperty.h" +#include "../gwen_checkbox.h" + +namespace Gwen +{ + namespace Controls + { + namespace Property + { + class GWEN_EXPORT Checkbox : public Property::Base + { + public: + + GWEN_CONTROL_INLINE( Checkbox, Property::Base ) + { + m_Checkbox = new Gwen::Controls::CheckBox( this ); + m_Checkbox->SetShouldDrawBackground( false ); + m_Checkbox->onCheckChanged.Add( this, &BaseClass::OnPropertyValueChanged ); + m_Checkbox->SetTabable( true ); + m_Checkbox->SetKeyboardInputEnabled( true ); + m_Checkbox->SetPos( 2, 1 ); + + SetHeight( 18 ); + } + + virtual TextObject GetPropertyValue() + { + return m_Checkbox->IsChecked() ? "1" : "0"; + } + + virtual void SetPropertyValue( const TextObject& v, bool bFireChangeEvents ) + { + if ( v == "1" || v == "true" || v == "TRUE" || v == "yes" || v == "YES" ) + return m_Checkbox->SetChecked( true ); + + return m_Checkbox->SetChecked( false ); + } + + virtual bool IsEditing() + { + return m_Checkbox->HasFocus(); + } + + virtual bool IsHovered() + { + return BaseClass::IsHovered() || m_Checkbox->IsHovered(); + } + + Gwen::Controls::CheckBox* m_Checkbox; + }; + } + } +} +#endif diff --git a/lib/gwen/controls/property/gwen_colorselector.h b/lib/gwen/controls/property/gwen_colorselector.h new file mode 100644 index 0000000..ce7a1ee --- /dev/null +++ b/lib/gwen/controls/property/gwen_colorselector.h @@ -0,0 +1,111 @@ +#pragma once +#ifndef GWEN_CONTROLS_PROPERTY_COLORSELECTOR_H +#define GWEN_CONTROLS_PROPERTY_COLORSELECTOR_H + +#include "../gwen_properties.h" +#include "../gwen_menu.h" +#include "../gwen_hsvcolorpicker.h" + +namespace Gwen +{ + namespace Controls + { + namespace Internal + { + class ColourButton : public Button + { + GWEN_CONTROL_INLINE ( ColourButton, Button ) + { + m_Color = Colors::Black; + SetText( "" ); + } + + void Render( Skin::Base* skin ) + { + skin->GetRender()->SetDrawColor( m_Color ); + skin->GetRender()->DrawFilledRect( GetRenderBounds() ); + } + + void SetColor( const Gwen::Color& col ){ m_Color = col; } + + Gwen::Color m_Color; + }; + } + + namespace Property + { + class ColorSelector : public Property::Text + { + GWEN_CONTROL_INLINE( ColorSelector, Property::Text ) + { + m_Button = new Controls::Internal::ColourButton( m_TextBox ); + m_Button->Dock( Pos::Right ); + m_Button->SetWidth( 20 ); + m_Button->onPress.Add( this, &ThisClass::OnButtonPress ); + m_Button->SetMargin( Margin( 1, 1, 1, 2 ) ); + } + + void OnButtonPress( Controls::Base* control ) + { + Gwen::Controls::Menu* pMenu = new Menu( GetCanvas() ); + pMenu->SetSize( 256, 180 ); + pMenu->SetDeleteOnClose( true ); + pMenu->SetDisableIconMargin( true ); + + Gwen::Controls::HSVColorPicker* picker = new Gwen::Controls::HSVColorPicker( pMenu ); + picker->Dock( Pos::Fill ); + picker->SetSize( 256, 128 ); + + float defaultColor[3]; + Gwen::Utility::Strings::To::Floats( m_TextBox->GetText().Get(), defaultColor, 3); + + picker->SetColor( Gwen::Color( defaultColor[0], defaultColor[1], defaultColor[2], 255 ), false, true ); + picker->onColorChanged.Add( this, &ThisClass::ColorChanged ); + + pMenu->Open( Pos::Right | Pos::Top ); + } + + void ColorChanged( Controls::Base* control ) + { + Gwen::Controls::HSVColorPicker* picker = gwen_cast( control ); + + Gwen::String colorStr; + colorStr += Gwen::Utility::ToString( ( int )picker->GetColor().r ) + " "; + colorStr += Gwen::Utility::ToString( ( int )picker->GetColor().g ) + " "; + colorStr += Gwen::Utility::ToString( ( int )picker->GetColor().b ); + + m_TextBox->SetText( colorStr ); + DoChanged(); + } + + virtual TextObject GetPropertyValue() + { + return m_TextBox->GetText(); + } + + virtual void SetPropertyValue( const TextObject& v, bool bFireChangeEvents ) + { + m_TextBox->SetText( v, bFireChangeEvents ); + } + + virtual bool IsEditing() + { + return m_TextBox == Gwen::KeyboardFocus; + } + + virtual void DoChanged() + { + BaseClass::DoChanged(); + + float col[3]; + Gwen::Utility::Strings::To::Floats( m_TextBox->GetText().Get(), col, 3); + + m_Button->SetColor( Gwen::Color( col[0], col[1], col[2] ) ); + } + + Controls::Internal::ColourButton* m_Button; + }; + } + } +} +#endif diff --git a/lib/gwen/controls/property/gwen_combobox.h b/lib/gwen/controls/property/gwen_combobox.h new file mode 100644 index 0000000..9ccef6f --- /dev/null +++ b/lib/gwen/controls/property/gwen_combobox.h @@ -0,0 +1,71 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTY_COMBOBOX_H +#define GWEN_CONTROLS_PROPERTY_COMBOBOX_H + +#include "gwen_baseproperty.h" +#include "../gwen_combobox.h" + +namespace Gwen +{ + namespace Controls + { + namespace Property + { + class GWEN_EXPORT ComboBox : public Property::Base + { + public: + + GWEN_CONTROL_INLINE( ComboBox, Property::Base ) + { + m_ComboBox = new Gwen::Controls::ComboBox( this ); + m_ComboBox->Dock( Pos::Fill ); + m_ComboBox->onSelection.Add( this, &BaseClass::OnPropertyValueChanged ); + m_ComboBox->SetTabable( true ); + m_ComboBox->SetKeyboardInputEnabled( true ); + m_ComboBox->SetShouldDrawBackground( false ); + + SetHeight( 18 ); + } + + virtual TextObject GetPropertyValue() + { + Gwen::Controls::Label* pControl = m_ComboBox->GetSelectedItem(); + if ( !pControl ) return ""; + + return pControl->GetName(); + } + + virtual void SetPropertyValue( const TextObject& v, bool bFireChangeEvents ) + { + m_ComboBox->SelectItemByName( v.Get(), bFireChangeEvents ); + } + + virtual bool IsEditing() + { + return m_ComboBox->HasFocus(); + } + + virtual bool IsHovered() + { + return BaseClass::IsHovered() || m_ComboBox->IsHovered(); + } + + Gwen::Controls::ComboBox* GetComboBox() + { + return m_ComboBox; + } + + protected: + + Gwen::Controls::ComboBox* m_ComboBox; + }; + } + } +} +#endif diff --git a/lib/gwen/controls/property/gwen_text.h b/lib/gwen/controls/property/gwen_text.h new file mode 100644 index 0000000..b922994 --- /dev/null +++ b/lib/gwen/controls/property/gwen_text.h @@ -0,0 +1,57 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONTROLS_PROPERTY_TEXT_H +#define GWEN_CONTROLS_PROPERTY_TEXT_H + +#include "gwen_baseproperty.h" +#include "../gwen_textbox.h" + +namespace Gwen +{ + namespace Controls + { + namespace Property + { + class GWEN_EXPORT Text : public Property::Base + { + public: + + GWEN_CONTROL_INLINE( Text, Property::Base ) + { + m_TextBox = new TextBox( this ); + m_TextBox->Dock( Pos::Fill ); + m_TextBox->SetShouldDrawBackground( false ); + m_TextBox->onTextChanged.Add( this, &BaseClass::OnPropertyValueChanged ); + } + + virtual TextObject GetPropertyValue() + { + return m_TextBox->GetText(); + } + + virtual void SetPropertyValue( const TextObject& v, bool bFireChangeEvents ) + { + m_TextBox->SetText( v, bFireChangeEvents ); + } + + virtual bool IsEditing() + { + return m_TextBox->HasFocus(); + } + + virtual bool IsHovered() + { + return BaseClass::IsHovered() || m_TextBox->IsHovered(); + } + + TextBox* m_TextBox; + }; + } + } +} +#endif diff --git a/lib/gwen/gwen.cpp b/lib/gwen/gwen.cpp new file mode 100644 index 0000000..edc6417 --- /dev/null +++ b/lib/gwen/gwen.cpp @@ -0,0 +1,47 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen.h" +#include +#include + +//#include "../../debug.h" +//#include "../../log.h" + +namespace Gwen +{ + // Globals + GWEN_EXPORT Controls::Base* HoveredControl = NULL; + GWEN_EXPORT Controls::Base* KeyboardFocus = NULL; + GWEN_EXPORT Controls::Base* MouseFocus = NULL; + + namespace Debug + { + void Msg( const char* str, ... ) + { + char strOut[1024]; + va_list s; + va_start( s, str ); + vsnprintf( strOut, sizeof(strOut), str, s ); + va_end(s); + //GwenUtil_OutputDebugCharString( strOut ); + //LOG_DEBUG("GWENUI", strOut); + } + void AssertCheck( bool b, const char* strMsg ) + { + if ( b ) return; + + Msg( "Assert: %s\n", strMsg ); + +#ifdef _WIN32 + MessageBoxA( NULL, strMsg, "Assert", MB_ICONEXCLAMATION | MB_OK ); +#endif + //BREAKPOINT; + } + } + +} diff --git a/lib/gwen/gwen.h b/lib/gwen/gwen.h new file mode 100644 index 0000000..d002237 --- /dev/null +++ b/lib/gwen/gwen.h @@ -0,0 +1,99 @@ +/* + GWEN + + Copyright (c) 2010 Facepunch Studios + + MIT License + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#pragma once +#ifndef GWEN_GWEN_H +#define GWEN_GWEN_H + +#include +#include +#include +#include +#include + +#include "gwen_macros.h" +#include "gwen_config.h" +#include "gwen_exports.h" +#include "gwen_structures.h" +#include "gwen_skin.h" +#include "controls/gwen_base.h" +#include "controls/gwen_canvas.h" +#include "gwen_align.h" + +// Enable the hook system (se Hook.h) +#define GWEN_HOOKSYSTEM + +namespace Gwen +{ + namespace Controls + { + class Base; + class Canvas; + } + + namespace Renderer + { + class Base; + } + + namespace Debug + { + void GWEN_EXPORT Msg( const char* str, ... ); + void GWEN_EXPORT AssertCheck( bool b, const char* strMsg ); + } + + + namespace Colors + { + static const Color Black ( 0, 0, 0, 255 ); + static const Color Red ( 255, 0, 0, 255 ); + static const Color Yellow ( 255, 255, 0, 255 ); + static const Color White ( 255, 255, 255, 255 ); + static const Color Blue ( 0, 0, 255, 255 ); + static const Color Green ( 0, 255, 0, 255 ); + static const Color Grey ( 200, 200, 200, 255 ); + static const Color GreyLight( 230, 230, 230, 255 ); + static const Color GwenPink ( 255, 65, 199, 255 ); + + + }; + + extern GWEN_EXPORT Controls::Base* HoveredControl; + extern GWEN_EXPORT Controls::Base* KeyboardFocus; + extern GWEN_EXPORT Controls::Base* MouseFocus; + + namespace Input + { + inline void Blur() + { + if ( KeyboardFocus ) + KeyboardFocus->Blur(); + } + } + +} //namespace Gwen + +#endif diff --git a/lib/gwen/gwen_align.h b/lib/gwen/gwen_align.h new file mode 100644 index 0000000..0512a92 --- /dev/null +++ b/lib/gwen/gwen_align.h @@ -0,0 +1,22 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_ALIGN_H +#define GWEN_ALIGN_H +#include "controls/gwen_base.h" + +namespace Gwen +{ + namespace Align + { + inline void PlaceBelow( Controls::Base* ctrl, Controls::Base* below, int iBorder = 0 ) + { + ctrl->SetPos( ctrl->X(), below->Bottom() + iBorder ); + } + } +} +#endif diff --git a/lib/gwen/gwen_anim.cpp b/lib/gwen/gwen_anim.cpp new file mode 100644 index 0000000..88c14f6 --- /dev/null +++ b/lib/gwen/gwen_anim.cpp @@ -0,0 +1,153 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_anim.h" +#include "gwen_utility.h" +#include + +using namespace Gwen; + +#ifndef GWEN_NO_ANIMATION + +static Gwen::Anim::Animation::List g_Animations; +static Gwen::Anim::Animation::ChildList g_AnimationsListed; + +void Gwen::Anim::Add( Gwen::Controls::Base* control, Animation* animation ) +{ + animation->m_Control = control; + + g_Animations[control].push_back( animation ); +} + +void Gwen::Anim::Cancel( Gwen::Controls::Base* control ) +{ + /* cannot use std::list iterator with algoryhtmns based on pointers + struct AnimDeletePredicate + { + AnimDeletePredicate( Gwen::Controls::Base* control ) + { + this->control = control; + } + + bool operator() ( Gwen::Anim::Animation* anim ) + { + return anim->m_Control == control; + } + + Gwen::Controls::Base* control; + }; + + std::remove_if ( g_Animations.begin(), g_Animations.end(), AnimDeletePredicate( control ) ); + */ + Gwen::Anim::Animation::List::iterator iAnimations; + if ((iAnimations = g_Animations.find(control)) != g_Animations.end()) + { + Gwen::Anim::Animation::ChildList &ChildAnimationsForControl = iAnimations->second; + Gwen::Anim::Animation::ChildList::iterator iAnimationChild = ChildAnimationsForControl.begin(); + if (iAnimationChild != ChildAnimationsForControl.end()) + { + do + { + delete (*iAnimationChild); + }while(++iAnimationChild != ChildAnimationsForControl.end()); + } + g_Animations.erase(iAnimations); + } +} + +void Gwen::Anim::Think() +{ + Gwen::Anim::Animation::List::iterator it = g_Animations.begin(); + + if ( it != g_Animations.end() ) + { + Gwen::Anim::Animation::ChildList::iterator itChild; + + Gwen::Anim::Animation* anim; + + do + { + if ((itChild = it->second.begin()) != it->second.end()) + { + do + { + anim = *itChild; + + anim->Think(); + + if ( anim->Finished() ) + { + itChild = it->second.erase( itChild ); + + delete anim; + } + else + { + ++itChild; + } + + }while(itChild != it->second.end()); + } + + }while(++it != g_Animations.end()); + } + +} + +Gwen::Anim::TimedAnimation::TimedAnimation( float fLength, float fDelay, float fEase ) +{ + m_fStart = Platform::GetTimeInSeconds() + fDelay; + m_fEnd = m_fStart + fLength; + m_fEase = fEase; + m_bStarted = false; + m_bFinished = false; +} + +float GetEased( float fTime, float fEase ) +{ + // Ease in and Out if ease is < 0 + if ( fEase < 0 ) + return -fTime/2 * (cos(3.14159f*fTime) - 1); + + return pow( fTime, fEase ); +} + +void Gwen::Anim::TimedAnimation::Think() +{ + if ( m_bFinished ) return; + + float fCurrent = Platform::GetTimeInSeconds(); + float fSecondsIn = fCurrent - m_fStart; + if ( fSecondsIn < 0.0f ) return; + + if ( !m_bStarted ) + { + m_bStarted = true; + OnStart(); + } + + float fDelta = fSecondsIn / ( m_fEnd - m_fStart ); + if ( fDelta < 0.0f ) fDelta = 0.0f; + if ( fDelta > 1.0f ) fDelta = 1.0f; + + float fEased = GetEased( fDelta, m_fEase ); + + Run( fEased ); + + if ( fDelta == 1.0f ) + { + m_bFinished = true; + OnFinish(); + } +} + +bool Gwen::Anim::TimedAnimation::Finished() +{ + return m_bFinished; +} + +#endif \ No newline at end of file diff --git a/lib/gwen/gwen_anim.h b/lib/gwen/gwen_anim.h new file mode 100644 index 0000000..5fbe36f --- /dev/null +++ b/lib/gwen/gwen_anim.h @@ -0,0 +1,177 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_ANIM_H +#define GWEN_ANIM_H +#include "gwen.h" +#include "controls/gwen_base.h" +#include "gwen_platform.h" + +#ifndef GWEN_NO_ANIMATION + +namespace Gwen +{ + namespace Anim + { + class GWEN_EXPORT Animation + { + public: + + typedef stl::list ChildList; + typedef stl::map< Gwen::Controls::Base *, ChildList > List; + + virtual void Think() = 0; + virtual bool Finished(){ return false; } + + virtual ~Animation() {} + + Gwen::Controls::Base* m_Control; + }; + + GWEN_EXPORT void Add( Gwen::Controls::Base* control, Animation* animation ); + GWEN_EXPORT void Cancel( Gwen::Controls::Base* control ); + GWEN_EXPORT void Think(); + + // + // Timed animation. Provides a useful base for animations. + // + class GWEN_EXPORT TimedAnimation : public Animation + { + public: + + TimedAnimation( float fLength, float fDelay = 0.0f, float fEase = -1.0f ); + + virtual void Think(); + virtual bool Finished(); + + // + // These are the magic functions you should be overriding + // + virtual void OnStart(){} + virtual void Run( float /*delta*/ ){} + virtual void OnFinish(){} + + protected: + + bool m_bStarted; + bool m_bFinished; + float m_fStart; + float m_fEnd; + float m_fEase; + }; + + namespace Size + { + class GWEN_EXPORT Height : public TimedAnimation + { + public: + + Height( int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = -1.0f ) : TimedAnimation( fLength, fDelay, fEase ) + { + m_iStartSize = iStartSize; + m_iDelta = iEndSize - m_iStartSize; + m_bHide = bHide; + } + + virtual void OnStart(){ m_Control->SetHeight( m_iStartSize ); } + virtual void Run( float delta ){ m_Control->SetHeight( m_iStartSize + (((float)m_iDelta) * delta) ); } + virtual void OnFinish(){ m_Control->SetHeight( m_iStartSize + m_iDelta ); m_Control->SetHidden( m_bHide ); } + + protected: + + int m_iStartSize; + int m_iDelta; + bool m_bHide; + }; + + class Width : public TimedAnimation + { + public: + + Width( int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = -1.0f ) : TimedAnimation( fLength, fDelay, fEase ) + { + m_iStartSize = iStartSize; + m_iDelta = iEndSize - m_iStartSize; + m_bHide = bHide; + } + + virtual void OnStart(){ m_Control->SetWidth( m_iStartSize ); } + virtual void Run( float delta ){ m_Control->SetWidth( m_iStartSize + (((float)m_iDelta) * delta) ); } + virtual void OnFinish(){ m_Control->SetWidth( m_iStartSize + m_iDelta ); m_Control->SetHidden( m_bHide ); } + + protected: + + int m_iStartSize; + int m_iDelta; + bool m_bHide; + }; + } + + namespace Pos + { + class GWEN_EXPORT X : public Anim::TimedAnimation + { + public: + + X( int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = 1.0f ) : TimedAnimation( fLength, fDelay, fEase ) + { + m_iStartSize = iStartSize; + m_iDelta = iEndSize - m_iStartSize; + m_bHide = bHide; + } + + virtual void OnStart(){ m_Control->SetPos( m_iStartSize, m_Control->GetPos().y ); } + virtual void Run( float delta ){ m_Control->SetPos( m_iStartSize + (((float)m_iDelta) * delta), m_Control->GetPos().y ); } + virtual void OnFinish(){ m_Control->SetPos( m_iStartSize + m_iDelta, m_Control->GetPos().y ); m_Control->SetHidden( m_bHide ); } + + protected: + + int m_iStartSize; + int m_iDelta; + bool m_bHide; + }; + + class Y : public Anim::TimedAnimation + { + public: + + Y( int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = 1.0f ) : TimedAnimation( fLength, fDelay, fEase ) + { + m_iStartSize = iStartSize; + m_iDelta = iEndSize - m_iStartSize; + m_bHide = bHide; + } + + virtual void OnStart(){ m_Control->SetPos( m_Control->GetPos().x, m_iStartSize ); } + virtual void Run( float delta ){ m_Control->SetPos( m_Control->GetPos().x, m_iStartSize + (((float)m_iDelta) * delta) ); } + virtual void OnFinish(){ m_Control->SetPos( m_Control->GetPos().x, m_iStartSize + m_iDelta ); m_Control->SetHidden( m_bHide ); } + + protected: + + int m_iStartSize; + int m_iDelta; + bool m_bHide; + }; + } + + namespace Tools + { + class Remove : public TimedAnimation + { + public: + + Remove( float fDelay = 0.0f ) : TimedAnimation( 0.0f, fDelay ){} + virtual void OnFinish(){ m_Control->DelayedDelete(); } + }; + } + + + } +} + +#endif +#endif diff --git a/lib/gwen/gwen_baserender.cpp b/lib/gwen/gwen_baserender.cpp new file mode 100644 index 0000000..354f9ee --- /dev/null +++ b/lib/gwen/gwen_baserender.cpp @@ -0,0 +1,209 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen.h" +#include "gwen_baserender.h" +#include "gwen_utility.h" +#include "gwen_platform.h" + +#include + +namespace Gwen +{ + namespace Renderer + { + + Base::Base() + { + m_RenderOffset = Gwen::Point( 0, 0 ); + m_fScale = 1.0f; + } + + Base::~Base() + { + if ( GetCTT() ) + GetCTT()->ShutDown(); + } + + void Base::DrawLinedRect( Gwen::Rect rect ) + { + DrawFilledRect( Gwen::Rect( rect.x, rect.y, rect.w, 1 ) ); + DrawFilledRect( Gwen::Rect( rect.x, rect.y + rect.h-1, rect.w, 1 ) ); + + DrawFilledRect( Gwen::Rect( rect.x, rect.y, 1, rect.h ) ); + DrawFilledRect( Gwen::Rect( rect.x + rect.w-1, rect.y, 1, rect.h ) ); + }; + + void Base::DrawPixel( int x, int y ) + { + DrawFilledRect( Gwen::Rect( x, y, 1, 1 ) ); + } + + void Base::DrawShavedCornerRect( Gwen::Rect rect, bool bSlight ) + { + // Draw INSIDE the w/h. + rect.w -= 1; + rect.h -= 1; + + if ( bSlight ) + { + DrawFilledRect( Gwen::Rect( rect.x+1, rect.y, rect.w-1, 1 ) ); + DrawFilledRect( Gwen::Rect( rect.x+1, rect.y + rect.h, rect.w-1, 1 ) ); + + DrawFilledRect( Gwen::Rect( rect.x, rect.y+1, 1, rect.h-1 ) ); + DrawFilledRect( Gwen::Rect( rect.x + rect.w, rect.y+1, 1, rect.h-1 ) ); + return; + } + + DrawPixel( rect.x+1, rect.y+1 ); + DrawPixel( rect.x+rect.w-1, rect.y+1 ); + + DrawPixel( rect.x+1, rect.y+rect.h-1 ); + DrawPixel( rect.x+rect.w-1, rect.y+rect.h-1 ); + + DrawFilledRect( Gwen::Rect( rect.x+2, rect.y, rect.w-3, 1 ) ); + DrawFilledRect( Gwen::Rect( rect.x+2, rect.y + rect.h, rect.w-3, 1 ) ); + + DrawFilledRect( Gwen::Rect( rect.x, rect.y+2, 1, rect.h-3 ) ); + DrawFilledRect( Gwen::Rect( rect.x + rect.w, rect.y+2, 1, rect.h-3 ) ); + } + + void Base::Translate( int& x, int& y ) + { + x += m_RenderOffset.x; + y += m_RenderOffset.y; + + x = ceil( ((float) x ) * m_fScale ); + y = ceil( ((float) y ) * m_fScale ); + } + + void Base::Translate( Gwen::Rect& rect ) + { + Translate( rect.x, rect.y ); + + rect.w = ceil(((float) rect.w ) * m_fScale); + rect.h = ceil(((float) rect.h ) * m_fScale); + } + + void Gwen::Renderer::Base::SetClipRegion( Gwen::Rect rect ) + { + m_rectClipRegion = rect; + } + + void Base::AddClipRegion( Gwen::Rect rect ) + { + rect.x = m_RenderOffset.x; + rect.y = m_RenderOffset.y; + + Gwen::Rect out = rect; + if ( rect.x < m_rectClipRegion.x ) + { + out.w -= ( m_rectClipRegion.x - out.x ); + out.x = m_rectClipRegion.x; + } + + if ( rect.y < m_rectClipRegion.y ) + { + out.h -= ( m_rectClipRegion.y - out.y ); + out.y = m_rectClipRegion.y; + } + + if ( rect.x + rect.w > m_rectClipRegion.x + m_rectClipRegion.w ) + { + out.w = (m_rectClipRegion.x + m_rectClipRegion.w) - out.x; + } + + if ( rect.y + rect.h > m_rectClipRegion.y + m_rectClipRegion.h ) + { + out.h = (m_rectClipRegion.y + m_rectClipRegion.h) - out.y; + } + + m_rectClipRegion = out; + } + + const Gwen::Rect& Base::ClipRegion() const + { + return m_rectClipRegion; + } + + bool Base::ClipRegionVisible() + { + if ( m_rectClipRegion.w <= 0 || m_rectClipRegion.h <= 0 ) + return false; + + return true; + } + + void Base::DrawMissingImage( Gwen::Rect pTargetRect ) + { + SetDrawColor( Colors::Red ); + DrawFilledRect( pTargetRect ); + } + + + /* + If they haven't defined these font functions in their renderer code + we just draw some rects where the letters would be to give them an idea. + */ + + void Base::RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::String& text ) + { + float fSize = pFont->size * Scale(); + + for ( float i=0; i= 'a' && chr <= 'z' ) + { + r.y += fSize * 0.5f; + r.h -= fSize * 0.4f; + } + else if ( chr == '.' || chr == ',' ) + { + r.x += 2; + r.y += r.h - 2; + r.w = 2; + r.h = 2; + } + else if ( chr == '\'' || chr == '`' || chr == '"' ) + { + r.x += 3; + r.w = 2; + r.h = 2; + } + + + if ( chr == 'o' || chr == 'O' || chr == '0' ) + DrawLinedRect( r ); + else + DrawFilledRect( r ); + } + } + + Gwen::Point Base::MeasureText( Gwen::Font* pFont, const Gwen::String& text ) + { + Gwen::Point p; + p.x = pFont->size * Scale() * (float)text.length() * 0.4; + p.y = pFont->size * Scale(); + + return p; + } + } +} \ No newline at end of file diff --git a/lib/gwen/gwen_baserender.h b/lib/gwen/gwen_baserender.h new file mode 100644 index 0000000..d425988 --- /dev/null +++ b/lib/gwen/gwen_baserender.h @@ -0,0 +1,139 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_BASERENDER_H +#define GWEN_BASERENDER_H + +#include "gwen_structures.h" + +namespace Gwen +{ + struct Font; + struct Texture; + class WindowProvider; + + namespace Renderer + { + class Base; + + class ICacheToTexture + { + public: + + virtual ~ICacheToTexture() {} + virtual void Initialize() = 0; + virtual void ShutDown() = 0; + virtual void SetupCacheTexture( Gwen::Controls::Base* control ) = 0; + virtual void FinishCacheTexture( Gwen::Controls::Base* control ) = 0; + virtual void DrawCachedControlTexture( Gwen::Controls::Base* control ) = 0; + virtual void CreateControlCacheTexture( Gwen::Controls::Base* control ) = 0; + virtual void UpdateControlCacheTexture( Gwen::Controls::Base* control ) = 0; + virtual void SetRenderer( Gwen::Renderer::Base* renderer ) = 0; + + }; + + class GWEN_EXPORT Base + { + public: + + Base(); + virtual ~Base(); + + virtual void Init(){}; + + virtual void Begin(){}; + virtual void End(){}; + + virtual void SetDrawColor( Color color ){}; + + virtual void DrawFilledRect( Gwen::Rect rect ){};; + + virtual void StartClip(){}; + virtual void EndClip(){}; + + virtual void LoadTexture( Gwen::Texture* pTexture ){}; + virtual void FreeTexture( Gwen::Texture* pTexture ){}; + virtual void DrawTexturedRect( Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1=0.0f, float v1=0.0f, float u2=1.0f, float v2=1.0f ){}; + virtual void DrawMissingImage( Gwen::Rect pTargetRect ); + virtual Gwen::Color PixelColour( Gwen::Texture* pTexture, unsigned int x, unsigned int y, const Gwen::Color& col_default = Gwen::Color( 255, 255, 255, 255 ) ){ return col_default; } + + virtual ICacheToTexture* GetCTT() { return NULL; } + + virtual void LoadFont( Gwen::Font* pFont ){}; + virtual void FreeFont( Gwen::Font* pFont ){}; + + // + // No need to implement these functions in your derived class, but if + // you can do them faster than the default implementation it's a good idea to. + // + virtual void DrawLinedRect( Gwen::Rect rect ); + virtual void DrawPixel( int x, int y ); + virtual void DrawShavedCornerRect( Gwen::Rect rect, bool bSlight = false ); + virtual Gwen::Point MeasureText( Gwen::Font* pFont, const Gwen::String& text ); + virtual void RenderText( Gwen::Font* pFont, Gwen::Point pos, const Gwen::String& text ); + + public: + + // + // Translate a panel's local drawing coordinate + // into view space, taking Offset's into account. + // + void Translate( int& x, int& y ); + void Translate( Gwen::Rect& rect ); + + // + // Set the rendering offset. You shouldn't have to + // touch these, ever. + // + void SetRenderOffset( const Gwen::Point& offset ){ m_RenderOffset = offset; } + void AddRenderOffset( const Gwen::Rect& offset ){ m_RenderOffset.x += offset.x; m_RenderOffset.y += offset.y; } + const Gwen::Point& GetRenderOffset() const { return m_RenderOffset; } + + private: + + Gwen::Point m_RenderOffset; + + public: + + void SetClipRegion( Gwen::Rect rect ); + void AddClipRegion( Gwen::Rect rect ); + bool ClipRegionVisible(); + const Gwen::Rect& ClipRegion() const; + + private: + + Gwen::Rect m_rectClipRegion; + ICacheToTexture* m_RTT; + + public: + + void SetScale( float fScale ){ m_fScale = fScale; } + float Scale() const { return m_fScale; } + + float m_fScale; + + + public: + + // + // Self Initialization, shutdown + // + + virtual bool InitializeContext( Gwen::WindowProvider* pWindow ){ return false; } + virtual bool ShutdownContext( Gwen::WindowProvider* pWindow ){ return false; } + virtual bool ResizedContext( Gwen::WindowProvider* pWindow, int w, int h ){ return false; } + + virtual bool BeginContext( Gwen::WindowProvider* pWindow){ return false; } + virtual bool EndContext( Gwen::WindowProvider* pWindow ){ return false; } + virtual bool PresentContext( Gwen::WindowProvider* pWindow ){ return false; } + + + + }; + } +} +#endif diff --git a/lib/gwen/gwen_config.h b/lib/gwen/gwen_config.h new file mode 100644 index 0000000..f46ce38 --- /dev/null +++ b/lib/gwen/gwen_config.h @@ -0,0 +1,16 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_CONFIG_H +#define GWEN_CONFIG_H + +// +// Disables animation functions. +// +//#define GWEN_NO_ANIMATION + +#endif diff --git a/lib/gwen/gwen_controllist.cpp b/lib/gwen/gwen_controllist.cpp new file mode 100644 index 0000000..b121d1a --- /dev/null +++ b/lib/gwen/gwen_controllist.cpp @@ -0,0 +1,68 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen.h" +#include "gwen_controllist.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +void ControlList::Enable() +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->SetDisabled( false ); + } +} + +void ControlList::Disable() +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->SetDisabled( true ); + } +} + +void ControlList::Show() +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->Show(); + } +} + +void ControlList::Hide() +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->Hide(); + } +} + +void ControlList::MoveBy( const Gwen::Point& point ) +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->MoveBy( point.x, point.y ); + } +} + +void ControlList::DoAction() +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->DoAction(); + } +} + +void ControlList::SetActionInternal( Gwen::Event::Handler* pObject, void (Gwen::Event::Handler::*f)( Gwen::Event::Info ), const Gwen::Event::Packet& packet ) +{ + for ( List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + (*it)->SetAction( pObject, f, packet ); + } +} \ No newline at end of file diff --git a/lib/gwen/gwen_controllist.h b/lib/gwen/gwen_controllist.h new file mode 100644 index 0000000..50bee98 --- /dev/null +++ b/lib/gwen/gwen_controllist.h @@ -0,0 +1,95 @@ +#pragma once +#ifndef GWEN_CONTROLLIST_H +#define GWEN_CONTROLLIST_H + +#include + +namespace Gwen +{ + struct Point; + class TextObject; + + namespace Controls + { + class Base; + } + + namespace Event + { + class Handler; + struct Information; + struct Packet; + + typedef const Gwen::Event::Information& Info; + } + + template < typename TYPE > + class TEasyList + { + public: + + typedef stl::list List; + + void Add( TYPE pControl ) + { + if ( Contains( pControl ) ) return; + + list.push_back( pControl ); + } + + void Remove( TYPE pControl ) + { + list.remove( pControl ); + } + + void Add( const List& list ) + { + for ( typename List::const_iterator it = list.begin(); it != list.end(); ++it ) + { + Add( *it ); + } + } + + void Add( const TEasyList& list ) + { + Add( list.list ); + } + + bool Contains( TYPE pControl ) const + { + typename List::const_iterator it = stl::find( list.begin(), list.end(), pControl ); + return it != list.end(); + } + + inline void Clear() + { + list.clear(); + } + + List list; + }; + + class ControlList : public TEasyList + { + public: + + void Enable(); + void Disable(); + + void Show(); + void Hide(); + + template void SetAction( Gwen::Event::Handler* ob, void (T::*f)( Gwen::Event::Info ), const Gwen::Event::Packet& packet ) { SetActionInternal( ob, static_cast(f), packet ); } + + void MoveBy( const Gwen::Point& point ); + + void DoAction(); + + protected: + + void SetActionInternal( Gwen::Event::Handler* pObject, void (Gwen::Event::Handler::*f)( Gwen::Event::Info ), const Gwen::Event::Packet& packet ); + }; + +}; + +#endif diff --git a/lib/gwen/gwen_controls.h b/lib/gwen/gwen_controls.h new file mode 100644 index 0000000..5f7a117 --- /dev/null +++ b/lib/gwen/gwen_controls.h @@ -0,0 +1,35 @@ +#pragma once +#ifndef GWEN_CONTROLS_H +#define GWEN_CONTROLS_H + +#include "controls/gwen_button.h" +#include "controls/gwen_dockbase.h" +#include "controls/gwen_fieldlabel.h" +#include "controls/gwen_groupbox.h" +#include "controls/gwen_imagepanel.h" +#include "controls/gwen_listbox.h" +#include "controls/gwen_propertytree.h" +#include "controls/property/gwen_checkbox.h" +#include "controls/property/gwen_colorselector.h" +#include "controls/property/gwen_text.h" +#include "controls/property/gwen_combobox.h" +#include "controls/gwen_statusbar.h" +#include "controls/gwen_tabcontrol.h" +#include "controls/gwen_text.h" +#include "controls/gwen_textbox.h" +#include "controls/gwen_windowcanvas.h" +#include "controls/gwen_menustrip.h" +#include "controls/gwen_toolbar.h" +#include "controls/gwen_splitters.h" +#include "controls/gwen_pagecontrol.h" +#include "controls/gwen_progressbar.h" +#include "controls/gwen_labelclickable.h" + +#include "controls/gwen_rectangle.h" + +#include "gwen_anim.h" + +#include "controls/layout/gwen_position.h" +#include "controls/layout/gwen_tile.h" + +#endif diff --git a/lib/gwen/gwen_draganddrop.cpp b/lib/gwen/gwen_draganddrop.cpp new file mode 100644 index 0000000..d950abb --- /dev/null +++ b/lib/gwen/gwen_draganddrop.cpp @@ -0,0 +1,243 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen.h" +#include "gwen_draganddrop.h" +#include "gwen_utility.h" +#include "gwen_platform.h" + +using namespace Gwen; +using namespace Gwen::DragAndDrop; + +DragAndDrop::Package* DragAndDrop::CurrentPackage = NULL; +Gwen::Controls::Base* DragAndDrop::HoveredControl = NULL; +Gwen::Controls::Base* DragAndDrop::SourceControl = NULL; + +static Gwen::Controls::Base* LastPressedControl = NULL; +static Gwen::Controls::Base* NewHoveredControl = NULL; +static Gwen::Point LastPressedPos; + +void DragAndDrop::ControlDeleted( Gwen::Controls::Base* pControl ) +{ + if ( SourceControl == pControl ) + { + SourceControl = NULL; + CurrentPackage = NULL; + HoveredControl = NULL; + LastPressedControl = NULL; + } + + if ( LastPressedControl == pControl ) + LastPressedControl = NULL; + + if ( HoveredControl == pControl ) + HoveredControl = NULL; + + if ( NewHoveredControl == pControl ) + NewHoveredControl = NULL; +} + +static int m_iMouseX = 0; +static int m_iMouseY = 0; + +bool DragAndDrop::Start( Gwen::Controls::Base* pControl, Package* pPackage ) +{ + if ( CurrentPackage ) + { + return false; + } + + CurrentPackage = pPackage; + SourceControl = pControl; + return true; +} + +bool OnDrop( int x, int y ) +{ + bool bSuccess = false; + + if ( DragAndDrop::HoveredControl ) + { + DragAndDrop::HoveredControl->DragAndDrop_HoverLeave( DragAndDrop::CurrentPackage ); + bSuccess = DragAndDrop::HoveredControl->DragAndDrop_HandleDrop( DragAndDrop::CurrentPackage, x, y ); + } + + // Report back to the source control, to tell it if we've been successful. + DragAndDrop::SourceControl->DragAndDrop_EndDragging( bSuccess, x, y ); + DragAndDrop::SourceControl->Redraw(); + + DragAndDrop::CurrentPackage = NULL; + DragAndDrop::SourceControl = NULL; + + return true; +} + +bool DragAndDrop::OnMouseButton( Gwen::Controls::Base* pHoveredControl, int x, int y, bool bDown ) +{ + if ( !bDown ) + { + LastPressedControl = NULL; + + // Not carrying anything, allow normal actions + if ( !CurrentPackage ) + return false; + + // We were carrying something, drop it. + OnDrop( x, y ); + return true; + } + + if ( !pHoveredControl ) return false; + if ( !pHoveredControl->DragAndDrop_Draggable() ) return false; + + // Store the last clicked on control. Don't do anything yet, + // we'll check it in OnMouseMoved, and if it moves further than + // x pixels with the mouse down, we'll start to drag. + LastPressedPos = Gwen::Point( x, y ); + LastPressedControl = pHoveredControl; + + return false; +} + +bool ShouldStartDraggingControl( int x, int y ) +{ + // We're not holding a control down.. + if ( !LastPressedControl ) return false; + + // Not been dragged far enough + int iLength = abs( x - LastPressedPos.x ) + abs( y - LastPressedPos.y ); + if ( iLength < 5 ) return false; + + // Create the dragging package + + DragAndDrop::CurrentPackage = LastPressedControl->DragAndDrop_GetPackage( LastPressedPos.x, LastPressedPos.y ); + + // We didn't create a package! + if ( !DragAndDrop::CurrentPackage ) + { + LastPressedControl = NULL; + DragAndDrop::SourceControl = NULL; + return false; + } + + + + // Now we're dragging something! + DragAndDrop::SourceControl = LastPressedControl; + Gwen::MouseFocus = NULL; + LastPressedControl = NULL; + DragAndDrop::CurrentPackage->drawcontrol = NULL; + + // Some controls will want to decide whether they should be dragged at that moment. + // This function is for them (it defaults to true) + if ( !DragAndDrop::SourceControl->DragAndDrop_ShouldStartDrag() ) + { + DragAndDrop::SourceControl = NULL; + DragAndDrop::CurrentPackage = NULL; + return false; + } + + DragAndDrop::SourceControl->DragAndDrop_StartDragging( DragAndDrop::CurrentPackage, LastPressedPos.x, LastPressedPos.y ); + + return true; + +} + +void UpdateHoveredControl( Gwen::Controls::Base* pCtrl, int x, int y ) +{ + // + // We use this global variable to represent our hovered control + // That way, if the new hovered control gets deleted in one of the + // Hover callbacks, we won't be left with a hanging pointer. + // This isn't ideal - but it's minimal. + // + NewHoveredControl = pCtrl; + + // Nothing to change.. + if ( DragAndDrop::HoveredControl == NewHoveredControl ) return; + + // We changed - tell the old hovered control that it's no longer hovered. + if ( DragAndDrop::HoveredControl && DragAndDrop::HoveredControl != NewHoveredControl ) + DragAndDrop::HoveredControl->DragAndDrop_HoverLeave( DragAndDrop::CurrentPackage ); + + // If we're hovering where the control came from, just forget it. + // By changing it to NULL here we're not going to show any error cursors + // it will just do nothing if you drop it. + if ( NewHoveredControl == DragAndDrop::SourceControl ) + NewHoveredControl = NULL; + + // Check to see if the new potential control can accept this type of package. + // If not, ignore it and show an error cursor. + while ( NewHoveredControl && !NewHoveredControl->DragAndDrop_CanAcceptPackage( DragAndDrop::CurrentPackage ) ) + { + // We can't drop on this control, so lets try to drop + // onto its parent.. + NewHoveredControl = NewHoveredControl->GetParent(); + + // Its parents are dead. We can't drop it here. + // Show the NO WAY cursor. + if ( !NewHoveredControl ) + { + Platform::SetCursor( CursorType::No ); + } + } + + // Become out new hovered control + DragAndDrop::HoveredControl = NewHoveredControl; + + // If we exist, tell us that we've started hovering. + if ( DragAndDrop::HoveredControl ) + { + DragAndDrop::HoveredControl->DragAndDrop_HoverEnter( DragAndDrop::CurrentPackage, x, y ); + } + + NewHoveredControl = NULL; +} + +void DragAndDrop::OnMouseMoved( Gwen::Controls::Base* pHoveredControl, int x, int y ) +{ + // Always keep these up to date, they're used to draw the dragged control. + m_iMouseX = x; + m_iMouseY = y; + + // If we're not carrying anything, then check to see if we should + // pick up from a control that we're holding down. If not, then forget it. + if ( !CurrentPackage && !ShouldStartDraggingControl( x, y ) ) + return; + + // Make sure the canvas redraws when we move + if ( CurrentPackage && CurrentPackage->drawcontrol ) + CurrentPackage->drawcontrol->Redraw(); + + // Swap to this new hovered control and notify them of the change. + UpdateHoveredControl( pHoveredControl, x, y ); + + if ( !HoveredControl ) return; + + // Update the hovered control every mouse move, so it can show where + // the dropped control will land etc.. + HoveredControl->DragAndDrop_Hover( CurrentPackage, x, y ); + + // Override the cursor - since it might have been set my underlying controls + // Ideally this would show the 'being dragged' control. TODO + Platform::SetCursor( CursorType::Normal ); + + pHoveredControl->Redraw(); +} + +void DragAndDrop::RenderOverlay( Gwen::Controls::Canvas* /*pCanvas*/, Skin::Base* skin ) +{ + if ( !CurrentPackage ) return; + if ( !CurrentPackage->drawcontrol ) return; + + Gwen::Point pntOld = skin->GetRender()->GetRenderOffset(); + + skin->GetRender()->AddRenderOffset( Gwen::Rect( m_iMouseX - SourceControl->X() - CurrentPackage->holdoffset.x, m_iMouseY - SourceControl->Y() - CurrentPackage->holdoffset.y, 0, 0 ) ); + CurrentPackage->drawcontrol->DoRender( skin ); + + skin->GetRender()->SetRenderOffset( pntOld ); +} \ No newline at end of file diff --git a/lib/gwen/gwen_draganddrop.h b/lib/gwen/gwen_draganddrop.h new file mode 100644 index 0000000..8cf2556 --- /dev/null +++ b/lib/gwen/gwen_draganddrop.h @@ -0,0 +1,33 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_DRAGANDDROP_H +#define GWEN_DRAGANDDROP_H + +#include "gwen_skin.h" +#include "gwen_structures.h" + +namespace Gwen +{ + namespace DragAndDrop + { + extern GWEN_EXPORT Package* CurrentPackage; + extern GWEN_EXPORT Gwen::Controls::Base* SourceControl; + extern GWEN_EXPORT Gwen::Controls::Base* HoveredControl; + + bool GWEN_EXPORT Start( Gwen::Controls::Base* pControl, Package* pPackage ); + + bool GWEN_EXPORT OnMouseButton( Gwen::Controls::Base* pHoveredControl, int x, int y, bool bDown ); + void GWEN_EXPORT OnMouseMoved( Gwen::Controls::Base* pHoveredControl, int x, int y ); + + void GWEN_EXPORT RenderOverlay( Gwen::Controls::Canvas* pCanvas, Skin::Base* skin ); + + void GWEN_EXPORT ControlDeleted( Gwen::Controls::Base* pControl ); + } + +} +#endif diff --git a/lib/gwen/gwen_events.cpp b/lib/gwen/gwen_events.cpp new file mode 100644 index 0000000..3dc771c --- /dev/null +++ b/lib/gwen/gwen_events.cpp @@ -0,0 +1,161 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_events.h" + +using namespace Gwen; +using namespace Gwen::Event; + + +Handler::Handler() +{ + +} + +Handler::~Handler() +{ + CleanLinks(); +} + +void Handler::CleanLinks() +{ + // Tell all the callers that we're dead + stl::list::iterator iter = m_Callers.begin(); + while ( iter != m_Callers.end() ) + { + Caller* pCaller = *iter; + UnRegisterCaller( pCaller ); + pCaller->RemoveHandler( this ); + iter = m_Callers.begin(); + } +} + +void Handler::RegisterCaller( Caller* pCaller ) +{ + m_Callers.push_back( pCaller ); +} + +void Handler::UnRegisterCaller( Caller* pCaller ) +{ + m_Callers.remove( pCaller ); +} + + +Caller::Caller() +{ + +} + +Caller::~Caller() +{ + CleanLinks(); +} + +void Caller::CleanLinks() +{ + stl::list::iterator iter; + for (iter = m_Handlers.begin(); iter != m_Handlers.end(); ++iter) + { + handler& h = *iter; + h.pObject->UnRegisterCaller( this ); + } + + m_Handlers.clear(); +} + +void Caller::Call( Controls::Base* pThis ) +{ + static Gwen::Event::Information info; + info.Control = pThis; + Call( pThis, info ); +} + +void Caller::Call( Controls::Base* pThis, Gwen::Event::Info information ) +{ + Gwen::Event::Information info; + info = information; + info.ControlCaller = pThis; + + stl::list::iterator iter; + for (iter = m_Handlers.begin(); iter != m_Handlers.end(); ++iter) + { + handler& h = *iter; + + info.Packet = &h.Packet; + + if ( h.fnFunction ) + (h.pObject->*h.fnFunction)( pThis ); + + if ( h.fnFunctionInfo ) + (h.pObject->*h.fnFunctionInfo)( info ); + + if ( h.fnFunctionBlank ) + (h.pObject->*h.fnFunctionBlank)(); + + } +} + +void Caller::AddInternal( Event::Handler* pObject, Event::Handler::Function pFunction ) +{ + handler h; + h.fnFunction = pFunction; + h.pObject = pObject; + + m_Handlers.push_back( h ); + + pObject->RegisterCaller( this ); +} + +void Caller::AddInternal( Event::Handler* pObject, Handler::FunctionWithInformation pFunction ) +{ + AddInternal( pObject, pFunction, Gwen::Event::Packet() ); +} + +void Caller::AddInternal( Event::Handler* pObject, Handler::FunctionWithInformation pFunction, const Gwen::Event::Packet& packet ) +{ + handler h; + h.fnFunctionInfo = pFunction; + h.pObject = pObject; + h.Packet = packet; + + m_Handlers.push_back( h ); + + pObject->RegisterCaller( this ); +} + +void Caller::AddInternal( Event::Handler* pObject, Handler::FunctionBlank pFunction ) +{ + handler h; + h.fnFunctionBlank = pFunction; + h.pObject = pObject; + + m_Handlers.push_back( h ); + + pObject->RegisterCaller( this ); +} + +void Caller::RemoveHandler( Event::Handler* pObject ) +{ + pObject->UnRegisterCaller( this ); + + stl::list::iterator iter = m_Handlers.begin(); + + while ( iter != m_Handlers.end() ) + { + handler& h = *iter; + + if ( h.pObject == pObject ) + { + iter = m_Handlers.erase( iter ); + } + else + { + ++iter; + } + } + +} \ No newline at end of file diff --git a/lib/gwen/gwen_events.h b/lib/gwen/gwen_events.h new file mode 100644 index 0000000..b0a45ee --- /dev/null +++ b/lib/gwen/gwen_events.h @@ -0,0 +1,172 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_EVENTS_H +#define GWEN_EVENTS_H + +#include +#include "gwen_exports.h" +#include "gwen_structures.h" +#include "gwen_textobject.h" +#include "gwen_controllist.h" + +namespace Gwen +{ + + namespace Controls + { + class Base; + } + + namespace Event + { + /* + + When adding an event hook you can add a Packet too + This will be passed in Event::Info when you receive an event + + */ + struct Packet + { + Packet( Gwen::Controls::Base* pControl = NULL ) + { + Control = pControl; + String = ""; + Integer = 0; + Float = 0.0f; + UnsignedLongLong = 0; + } + + Gwen::Controls::Base* Control; + Gwen::String String; + int Integer; + float Float; + unsigned long long UnsignedLongLong; + }; + + /* + + Passed to an event hook + + */ + struct Information + { + Information(){ Init(); } + Information( Gwen::Controls::Base* pctrl ){ Init(); Control = pctrl; } + + void Init() + { + ControlCaller = NULL; + Packet = NULL; + Control = NULL; + Integer = 0; + } + + // This is set by the event caller, it will always be + // the control which is calling the event. + Gwen::Controls::Base* ControlCaller; + + // This is set by the event hook + // ie onDoSomething.Add( this, &ThisClass::MyFunction, Gwen::Event::Packet( "Something" ) + Gwen::Event::Packet* Packet; + + // + // These are set by the event and may or may not be set. + // + Gwen::Controls::Base* Control; + + Gwen::ControlList ControlList; + Gwen::TextObject String; + Gwen::Point Point; + int Integer; + + }; + + typedef const Gwen::Event::Information& Info; + + + class Caller; + + // A class must be derived from this + class GWEN_EXPORT Handler + { + public: + + Handler(); + virtual ~Handler(); + + void RegisterCaller( Caller* ); + void UnRegisterCaller( Caller* ); + + protected: + + void CleanLinks(); + stl::list m_Callers; + + public: + + typedef void (Handler::*Function)( Gwen::Controls::Base* pFromPanel ); + typedef void (Handler::*FunctionBlank)(); + typedef void (Handler::*FunctionWithInformation)( Gwen::Event::Info info ); + + }; + + + + // + // + // + class GWEN_EXPORT Caller + { + public: + + Caller(); + ~Caller(); + + void Call( Controls::Base* pThis ); + void Call( Controls::Base* pThis, Gwen::Event::Info info ); + + template void Add( Event::Handler* ob, T f ) { AddInternal( ob, static_cast(f) ); } + template void Add( Event::Handler* ob, void (T::*f)( Gwen::Event::Info ) ) { AddInternal( ob, static_cast(f) ); } + template void Add( Event::Handler* ob, void (T::*f)( Gwen::Event::Info ), const Gwen::Event::Packet& packet ) { AddInternal( ob, static_cast(f), packet ); } + template void Add( Event::Handler* ob, void (T::*f)() ) { AddInternal( ob, static_cast(f) ); } + + void RemoveHandler( Event::Handler* pObject ); + + protected: + + void CleanLinks(); + void AddInternal( Event::Handler* pObject, Handler::Function pFunction ); + void AddInternal( Event::Handler* pObject, Handler::FunctionWithInformation pFunction ); + void AddInternal( Event::Handler* pObject, Handler::FunctionWithInformation pFunction, const Gwen::Event::Packet& packet ); + void AddInternal( Event::Handler* pObject, Handler::FunctionBlank pFunction ); + + struct handler + { + handler() + { + fnFunction = NULL; + fnFunctionInfo = NULL; + fnFunctionBlank = NULL; + pObject = NULL; + } + + Handler::Function fnFunction; + Handler::FunctionWithInformation fnFunctionInfo; + Handler::FunctionBlank fnFunctionBlank; + + Event::Handler* pObject; + Gwen::Event::Packet Packet; + }; + + stl::list m_Handlers; + }; + + } + +} +#endif diff --git a/lib/gwen/gwen_exports.h b/lib/gwen/gwen_exports.h new file mode 100644 index 0000000..0d3e19c --- /dev/null +++ b/lib/gwen/gwen_exports.h @@ -0,0 +1,81 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_EXPORTS_H +#define GWEN_EXPORTS_H + +#define GWEN_COMPILE_STATIC + +// +// GWEN_COMPILE_DLL +// - We're compiling the Gwen.DLL (or .dylib etc) +// +#if defined(GWEN_COMPILE_DLL) + +#ifdef _WIN32 + #if defined(__GNUC__) + #define GWEN_EXPORT __attribute__((dllexport)) + #else + #define GWEN_EXPORT __declspec(dllexport) + #endif +#endif +// +// GWEN_COMPILE_STATIC +// - We're compiling gwen as a static library +// +#elif defined(GWEN_COMPILE_STATIC) + + #define GWEN_EXPORT + +// +// GWEN_DLL +// - We're including gwen using the dll +// +#elif defined( GWEN_DLL ) + +#ifdef _WIN32 + #ifdef __GNUC__ + #define GWEN_EXPORT __attribute__((dllimport)) + #else + #define GWEN_EXPORT __declspec(dllimport) + #endif + + #ifdef _MSC_VER + #ifndef _DEBUG + #pragma comment ( lib, "gwen.lib" ) + #else + #pragma comment ( lib, "gwend.lib" ) + #endif + #endif +#endif + +// +// - We're including gwen using a static library +// +#else + + #define GWEN_EXPORT + +#ifdef _WIN32 + #ifdef _MSC_VER + #ifndef _DEBUG + #pragma comment ( lib, "gwen_static.lib" ) + #else + #pragma comment ( lib, "gwend_static.lib" ) + #endif + #endif +#endif + +#endif + +#ifndef GWEN_EXPORT + #define GWEN_EXPORT +#endif + + + +#endif // GWEN_EXPORTS_H \ No newline at end of file diff --git a/lib/gwen/gwen_font.h b/lib/gwen/gwen_font.h new file mode 100644 index 0000000..91b8df9 --- /dev/null +++ b/lib/gwen/gwen_font.h @@ -0,0 +1,48 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_FONT_H +#define GWEN_FONT_H + +#include +#include + +#include "gwen_baserender.h" + +namespace Gwen +{ + + struct Font + { + typedef stl::list List; + + Font() + { + data = NULL; + facename = "Arial"; + size = 10; + realsize = 0; + bold = false; + } + + String facename; + float size; + bool bold; + + // This should be set by the renderer + // if it tries to use a font where it's + // NULL. + void* data; + + // This is the real font size, after it's + // been scaled by Render->Scale() + float realsize; + + }; + +} //namespace Gwen +#endif diff --git a/lib/gwen/gwen_hook.cpp b/lib/gwen/gwen_hook.cpp new file mode 100644 index 0000000..cbdfe32 --- /dev/null +++ b/lib/gwen/gwen_hook.cpp @@ -0,0 +1,32 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_hook.h" + +#ifdef GWEN_HOOKSYSTEM + +using namespace Gwen; +using namespace Gwen::Hook; + +stl::list g_HookList; + +void Gwen::Hook::AddHook( BaseHook* pHook ) +{ + g_HookList.push_back( pHook ); +} + +void Gwen::Hook::RemoveHook( BaseHook* pHook ) +{ + g_HookList.remove( pHook ); +} + +HookList& Gwen::Hook::GetHookList() +{ + return g_HookList; +} + +#endif \ No newline at end of file diff --git a/lib/gwen/gwen_hook.h b/lib/gwen/gwen_hook.h new file mode 100644 index 0000000..6f833b7 --- /dev/null +++ b/lib/gwen/gwen_hook.h @@ -0,0 +1,82 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_HOOK_H +#define GWEN_HOOK_H + +#include "gwen.h" +#include + +#ifdef GWEN_HOOKSYSTEM + +namespace Gwen +{ + namespace Hook + { + class GWEN_EXPORT BaseHook + { + public: + + virtual bool OnControlClicked( Gwen::Controls::Base*, int /*iMouseX*/, int /*iMouseY*/ ){ return false; }; + }; + + typedef stl::list HookList; + + GWEN_EXPORT HookList& GetHookList(); + + GWEN_EXPORT void AddHook( BaseHook* pHook ); + GWEN_EXPORT void RemoveHook( BaseHook* pHook ); + + template< typename fnc > + bool CallHook( fnc f ) + { + for ( HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it ) + { + if ( ((*it)->*f)() ) return true; + } + + return false; + } + + template< typename fnc, typename AA > + bool CallHook( fnc f, AA a ) + { + for ( HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it ) + { + if ( ((*it)->*f)( a ) ) return true; + } + + return false; + } + + template< typename fnc, typename AA, typename AB > + bool CallHook( fnc f, AA a, AB b ) + { + for ( HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it ) + { + if ( ((*it)->*f)( a, b ) ) return true; + } + + return false; + } + + template< typename fnc, typename AA, typename AB, typename AC > + bool CallHook( fnc f, AA a, AB b, AC c ) + { + for ( HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it ) + { + if ( ((*it)->*f)( a, b, c ) ) return true; + } + + return false; + } + } + +} + +#endif +#endif diff --git a/lib/gwen/gwen_inputhandler.cpp b/lib/gwen/gwen_inputhandler.cpp new file mode 100644 index 0000000..cd10c21 --- /dev/null +++ b/lib/gwen/gwen_inputhandler.cpp @@ -0,0 +1,369 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_inputhandler.h" +#include "controls/gwen_base.h" +#include "gwen_draganddrop.h" +#include "gwen_hook.h" +#include "gwen_platform.h" + +#define DOUBLE_CLICK_SPEED 0.5f +#define MAX_MOUSE_BUTTONS 5 + +using namespace Gwen; + + +struct Action +{ + unsigned char type; + + int x, y; + char chr; +}; + +static const float KeyRepeatRate = 0.03f; +static const float KeyRepeatDelay = 0.3f; + +struct t_KeyData +{ + t_KeyData() + { + for ( int i=0; iGetControlAt( MousePosition.x, MousePosition.y ); + + if ( pHovered != Gwen::HoveredControl ) + { + if ( Gwen::HoveredControl ) + { + Controls::Base* OldHover = Gwen::HoveredControl; + Gwen::HoveredControl = NULL; + OldHover->OnMouseLeave(); + } + + Gwen::HoveredControl = pHovered; + + if ( Gwen::HoveredControl ) + { + Gwen::HoveredControl->OnMouseEnter(); + } + } + + if ( Gwen::MouseFocus && Gwen::MouseFocus->GetCanvas() == pInCanvas ) + { + if ( Gwen::HoveredControl ) + { + Controls::Base* OldHover = Gwen::HoveredControl; + Gwen::HoveredControl = NULL; + OldHover->Redraw(); + } + + Gwen::HoveredControl = Gwen::MouseFocus; + } + +} + +void FindKeyboardFocus( Controls::Base* pControl ) +{ + if ( !pControl ) return; + if ( pControl->GetKeyboardInputEnabled() ) + { + //Make sure none of our children have keyboard focus first - todo recursive + for (Controls::Base::List::iterator iter = pControl->Children.begin(); iter != pControl->Children.end(); ++iter) + { + Controls::Base* pChild = *iter; + if ( pChild == Gwen::KeyboardFocus ) + return; + } + + pControl->Focus(); + return; + } + + return FindKeyboardFocus( pControl->GetParent() ); +} + +Gwen::Point Gwen::Input::GetMousePosition() +{ + return MousePosition; +} + +void Gwen::Input::OnCanvasThink( Controls::Base* pControl ) +{ + if ( Gwen::MouseFocus && !Gwen::MouseFocus->Visible() ) + Gwen::MouseFocus = NULL; + + if ( Gwen::KeyboardFocus && ( !Gwen::KeyboardFocus->Visible() || !KeyboardFocus->GetKeyboardInputEnabled() ) ) + Gwen::KeyboardFocus = NULL; + + if ( !KeyboardFocus ) return; + if ( KeyboardFocus->GetCanvas() != pControl ) return; + + float fTime = Gwen::Platform::GetTimeInSeconds(); + + // + // Simulate Key-Repeats + // + for ( int i=0; i KeyData.NextRepeat[i] ) + { + KeyData.NextRepeat[i] = Gwen::Platform::GetTimeInSeconds() + KeyRepeatRate; + + if ( KeyboardFocus ) + { + KeyboardFocus->OnKeyPress( i ); + } + } + } +} + +bool Gwen::Input::IsKeyDown( int iKey ) +{ + return KeyData.KeyState[ iKey ]; +} + +bool Gwen::Input::IsLeftMouseDown() +{ + return KeyData.LeftMouseDown; +} + +bool Gwen::Input::IsRightMouseDown() +{ + return KeyData.RightMouseDown; +} + +void Gwen::Input::OnMouseMoved( Controls::Base* pCanvas, int x, int y, int /*deltaX*/, int /*deltaY*/ ) +{ + MousePosition.x = x; + MousePosition.y = y; + + UpdateHoveredControl( pCanvas ); +} + +bool Gwen::Input::OnMouseClicked( Controls::Base* pCanvas, int iMouseButton, bool bDown ) +{ + // If we click on a control that isn't a menu we want to close + // all the open menus. Menus are children of the canvas. + if ( bDown && (!Gwen::HoveredControl || !Gwen::HoveredControl->IsMenuComponent()) ) + { + pCanvas->CloseMenus(); + } + + if ( !Gwen::HoveredControl ) return false; + if ( Gwen::HoveredControl->GetCanvas() != pCanvas ) return false; + if ( !Gwen::HoveredControl->Visible() ) return false; + if ( Gwen::HoveredControl == pCanvas ) return false; + + if ( iMouseButton > MAX_MOUSE_BUTTONS ) + return false; + + if ( iMouseButton == 0 ) KeyData.LeftMouseDown = bDown; + else if ( iMouseButton == 1 ) KeyData.RightMouseDown = bDown; + + // Double click. + // Todo: Shouldn't double click if mouse has moved significantly + bool bIsDoubleClick = false; + + if ( bDown && + g_pntLastClickPos.x == MousePosition.x && + g_pntLastClickPos.y == MousePosition.y && + ( Gwen::Platform::GetTimeInSeconds() - g_fLastClickTime[ iMouseButton ] ) < DOUBLE_CLICK_SPEED ) + { + bIsDoubleClick = true; + } + + if ( bDown && !bIsDoubleClick ) + { + g_fLastClickTime[ iMouseButton ] = Gwen::Platform::GetTimeInSeconds(); + g_pntLastClickPos = MousePosition; + } + + if ( bDown ) + { + FindKeyboardFocus( Gwen::HoveredControl ); + } + + Gwen::HoveredControl->UpdateCursor(); + + // This tells the child it has been touched, which + // in turn tells its parents, who tell their parents. + // This is basically so that Windows can pop themselves + // to the top when one of their children have been clicked. + if ( bDown ) + Gwen::HoveredControl->Touch(); + +#ifdef GWEN_HOOKSYSTEM + if ( bDown ) + { + if ( Hook::CallHook( &Hook::BaseHook::OnControlClicked, Gwen::HoveredControl, MousePosition.x, MousePosition.y ) ) + return true; + } +#endif + + switch ( iMouseButton ) + { + case 0: + { + if ( DragAndDrop::OnMouseButton( Gwen::HoveredControl, MousePosition.x, MousePosition.y, bDown ) ) + return true; + + if ( bIsDoubleClick ) Gwen::HoveredControl->OnMouseDoubleClickLeft( MousePosition.x, MousePosition.y ); + else Gwen::HoveredControl->OnMouseClickLeft( MousePosition.x, MousePosition.y, bDown ); + return true; + } + + case 1: + { + if ( bIsDoubleClick ) Gwen::HoveredControl->OnMouseDoubleClickRight( MousePosition.x, MousePosition.y ); + else Gwen::HoveredControl->OnMouseClickRight( MousePosition.x, MousePosition.y, bDown ); + return true; + } + } + + return false; +} + +bool Gwen::Input::HandleAccelerator( Controls::Base* pCanvas, char chr ) +{ + //Build the accelerator search string + Gwen::String accelString; + + if ( Gwen::Input::IsControlDown() ) + accelString += "CTRL+"; + + if ( Gwen::Input::IsShiftDown() ) + accelString += "SHIFT+"; + + chr = toupper( chr ); + + accelString += chr; + + //Debug::Msg("Accelerator string :%S\n", accelString.c_str()); + + if ( Gwen::KeyboardFocus && Gwen::KeyboardFocus->HandleAccelerator( accelString ) ) + return true; + + if ( Gwen::MouseFocus && Gwen::MouseFocus->HandleAccelerator( accelString ) ) + return true; + + if ( pCanvas->HandleAccelerator( accelString ) ) + return true; + + return false; +} + +bool Gwen::Input::DoSpecialKeys( Controls::Base* pCanvas, char chr ) +{ + if ( !Gwen::KeyboardFocus ) return false; + if ( Gwen::KeyboardFocus->GetCanvas() != pCanvas ) return false; + if ( !Gwen::KeyboardFocus->Visible() ) return false; + if ( !Gwen::Input::IsControlDown() ) return false; + + if ( chr == 'C' || chr == 'c' ) + { + Gwen::KeyboardFocus->OnCopy(NULL); + return true; + } + + if ( chr == 'V' || chr == 'v' ) + { + Gwen::KeyboardFocus->OnPaste(NULL); + return true; + } + + if ( chr == 'X' || chr == 'x' ) + { + Gwen::KeyboardFocus->OnCut(NULL); + return true; + } + + if ( chr == 'A' || chr == 'a' ) + { + Gwen::KeyboardFocus->OnSelectAll(NULL); + return true; + } + + return false; +} + +bool Gwen::Input::OnKeyEvent( Controls::Base* pCanvas, int iKey, bool bDown ) +{ + Gwen::Controls::Base* pTarget = Gwen::KeyboardFocus; + if ( pTarget && pTarget->GetCanvas() != pCanvas ) pTarget = NULL; + if ( pTarget && !pTarget->Visible() ) pTarget = NULL; + + if ( bDown ) + { + if ( !KeyData.KeyState[ iKey ] ) + { + KeyData.KeyState[ iKey ] = true; + KeyData.NextRepeat[ iKey ] = Gwen::Platform::GetTimeInSeconds() + KeyRepeatDelay; + KeyData.Target = pTarget; + + if ( pTarget ) + return pTarget->OnKeyPress( iKey ); + } + } + else + { + if ( KeyData.KeyState[ iKey ] ) + { + KeyData.KeyState[ iKey ] = false; + + // BUG BUG. This causes shift left arrow in textboxes + // to not work. What is disabling it here breaking? + //KeyData.Target = NULL; + + if ( pTarget ) + return pTarget->OnKeyRelease( iKey ); + } + } + + return false; +} \ No newline at end of file diff --git a/lib/gwen/gwen_inputhandler.h b/lib/gwen/gwen_inputhandler.h new file mode 100644 index 0000000..2755d30 --- /dev/null +++ b/lib/gwen/gwen_inputhandler.h @@ -0,0 +1,81 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_INPUTHANDLER_H +#define GWEN_INPUTHANDLER_H + +#include "gwen.h" + +namespace Gwen +{ + namespace Controls + { + class Base; + } + + namespace Key + { + const unsigned char Invalid = 0; + const unsigned char Return = 1; + const unsigned char Backspace = 2; + const unsigned char Delete = 3; + const unsigned char Left = 4; + const unsigned char Right = 5; + const unsigned char Shift = 6; + const unsigned char Tab = 7; + const unsigned char Space = 8; + const unsigned char Home = 9; + const unsigned char End = 10; + const unsigned char Control = 11; + const unsigned char Up = 12; + const unsigned char Down = 13; + const unsigned char Escape = 14; + const unsigned char Alt = 15; + + const unsigned char Count = 16; + } + + namespace Input + { + namespace Message + { + enum + { + Copy, + Paste, + Cut, + Undo, + Redo, + SelectAll + }; + }; + + + + // For use in panels + bool GWEN_EXPORT IsKeyDown( int iKey ); + bool GWEN_EXPORT IsLeftMouseDown(); + bool GWEN_EXPORT IsRightMouseDown(); + Gwen::Point GWEN_EXPORT GetMousePosition(); + + inline bool IsShiftDown(){ return IsKeyDown( Gwen::Key::Shift ); } + inline bool IsControlDown(){ return IsKeyDown( Gwen::Key::Control ); } + + // Does copy, paste etc + bool GWEN_EXPORT DoSpecialKeys( Controls::Base* pCanvas, char chr ); + bool GWEN_EXPORT HandleAccelerator( Controls::Base* pCanvas, char chr ); + + // Send input to canvas for study + void GWEN_EXPORT OnMouseMoved( Controls::Base* pCanvas, int x, int y, int deltaX, int deltaY ); + bool GWEN_EXPORT OnMouseClicked( Controls::Base* pCanvas, int iButton, bool bDown ); + bool GWEN_EXPORT OnKeyEvent( Controls::Base* pCanvas, int iKey, bool bDown ); + void GWEN_EXPORT OnCanvasThink( Controls::Base* pControl ); + + + }; +} +#endif diff --git a/lib/gwen/gwen_macros.h b/lib/gwen/gwen_macros.h new file mode 100644 index 0000000..faced0c --- /dev/null +++ b/lib/gwen/gwen_macros.h @@ -0,0 +1,78 @@ + +// C RunTime Header Files +#ifndef GWEN_MACROS_H +#define GWEN_MACROS_H +#include +#include +#include +#include + +// Not tied to platform api. +#define GwenUtil_Min( a, b ) ( ( (a) < (b) ) ? (a) : (b) ) +#define GwenUtil_Max( a, b ) ( ( (a) > (b) ) ? (a) : (b) ) + +#ifdef _WIN32 + + #ifndef NOMINMAX + #define NOMINMAX + #endif + #include + + + #define GwenUtil_OutputDebugCharString( lpOutputString ) OutputDebugStringA( lpOutputString ) + #define GwenUtil_OutputDebugWideString( lpOutputString ) OutputDebugStringW( lpOutputString ) + //#define GwenUtil_WideStringToFloat( _Str ) _wtof( _Str ) + +#elif defined(__APPLE__) + + // HACK: this doesn't seem to be needed? can cause type redefinition errors + // with 'Rect' in certain scenarios. + // compiles fine with this commented out... + //#include + #define GwenUtil_OutputDebugCharString( lpOutputString ) //printf( lpOutputString ) + #define GwenUtil_OutputDebugWideString( lpOutputString ) //wprintf( lpOutputString ) + //#define GwenUtil_WideStringToFloat( _Str ) wcstof(_Str, NULL) + +#elif defined(__linux__) + + #define GwenUtil_OutputDebugCharString( lpOutputString ) //printf( lpOutputString ) + #define GwenUtil_OutputDebugWideString( lpOutputString ) //wprintf( lpOutputString ) + //#define GwenUtil_WideStringToFloat( _Str ) wcstof(_Str, NULL) + +#else + + #define GwenUtil_OutputDebugCharString( lpOutputString ) //printf( lpOutputString ) + #define GwenUtil_OutputDebugWideString( lpOutputString ) //wprintf( lpOutputString ) + +#endif + + +namespace Gwen +{ + template + T1 Clamp( T1 current, T2 vmin, T3 vmax ) + { + if ( current > vmax ) return (T1)vmax; + if ( current < vmin ) return (T1)vmin; + return current; + } + + template + inline T Approach( T fCurrent, T fTarget, T2 fDelta ) + { + if ( fCurrent < fTarget ) + { + fCurrent += fDelta; + if ( fCurrent > fTarget ) return fTarget; + } + else if ( fCurrent > fTarget ) + { + fCurrent -= fDelta; + if ( fCurrent < fTarget ) return fTarget; + } + + return fCurrent; + } +} + +#endif diff --git a/lib/gwen/gwen_platform.h b/lib/gwen/gwen_platform.h new file mode 100644 index 0000000..e6817af --- /dev/null +++ b/lib/gwen/gwen_platform.h @@ -0,0 +1,67 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_PLATFORM_H +#define GWEN_PLATFORM_H + +#include "gwen_structures.h" +#include "gwen_events.h" + +namespace Gwen +{ + namespace Platform + { + // + // Do nothing for this many milliseconds + // + GWEN_EXPORT void Sleep( unsigned int iMS ); + + // + // Set the system cursor to iCursor + // Cursors are defined in Structures.h + // + GWEN_EXPORT void SetCursor( unsigned char iCursor ); + + // + // + // + GWEN_EXPORT void GetCursorPos( Gwen::Point &p ); + GWEN_EXPORT void GetDesktopSize( int& w, int &h ); + + // + // Used by copy/paste + // + GWEN_EXPORT String GetClipboardText(); + GWEN_EXPORT bool SetClipboardText( const String& str ); + + // + // Needed for things like double click + // + GWEN_EXPORT float GetTimeInSeconds(); + + // + // System Dialogs ( Can return false if unhandled ) + // + GWEN_EXPORT bool FileOpen( const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ); + GWEN_EXPORT bool FileSave( const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ); + GWEN_EXPORT bool FolderOpen( const String& Name, const String& StartPath, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ); + + + // + // Window Creation + // + GWEN_EXPORT void* CreatePlatformWindow( int x, int y, int w, int h, const Gwen::String& strWindowTitle ); + GWEN_EXPORT void DestroyPlatformWindow( void* pPtr ); + GWEN_EXPORT void SetBoundsPlatformWindow( void* pPtr, int x, int y, int w, int h ); + GWEN_EXPORT void MessagePump( void* pWindow, Gwen::Controls::Canvas* ptarget ); + GWEN_EXPORT bool HasFocusPlatformWindow( void* pPtr ); + GWEN_EXPORT void SetWindowMaximized( void* pPtr, bool bMaximized, Gwen::Point& pNewPos, Gwen::Point& pNewSize ); + GWEN_EXPORT void SetWindowMinimized( void* pPtr, bool bMinimized ); + } + +} +#endif diff --git a/lib/gwen/gwen_skin.cpp b/lib/gwen/gwen_skin.cpp new file mode 100644 index 0000000..cad4032 --- /dev/null +++ b/lib/gwen/gwen_skin.cpp @@ -0,0 +1,129 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen.h" +#include + +namespace Gwen +{ + namespace Skin + { + /* + + Here we're drawing a few symbols such as the directional arrows and the checkbox check + + Texture'd skins don't generally use these - but the Simple skin does. We did originally + use the marlett font to draw these.. but since that's a Windows font it wasn't a very + good cross platform solution. + + */ + + void Base::DrawArrowDown( Gwen::Rect rect ) + { + float x = (rect.w / 5.0f); + float y = (rect.h / 5.0f); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*0.0f, rect.y + y*1.0f, x, y*1.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*1.0f, x, y*2.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*2.0f, rect.y + y*1.0f, x, y*3.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*3.0f, rect.y + y*1.0f, x, y*2.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*4.0f, rect.y + y*1.0f, x, y*1.0f ) ); + } + + void Base::DrawArrowUp( Gwen::Rect rect ) + { + float x = (rect.w / 5.0f); + float y = (rect.h / 5.0f); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*0.0f, rect.y + y*3.0f, x, y*1.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*2.0f, x, y*2.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*2.0f, rect.y + y*1.0f, x, y*3.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*3.0f, rect.y + y*2.0f, x, y*2.0f ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*4.0f, rect.y + y*3.0f, x, y*1.0f ) ); + } + + void Base::DrawArrowLeft( Gwen::Rect rect ) + { + float x = (rect.w / 5.0f); + float y = (rect.h / 5.0f); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*3.0f, rect.y + y*0.0f, x*1.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*2.0f, rect.y + y*1.0f, x*2.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*2.0f, x*3.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*2.0f, rect.y + y*3.0f, x*2.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*3.0f, rect.y + y*4.0f, x*1.0f, y ) ); + } + + void Base::DrawArrowRight( Gwen::Rect rect ) + { + float x = (rect.w / 5.0f); + float y = (rect.h / 5.0f); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*0.0f, x*1.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*1.0f, x*2.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*2.0f, x*3.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*3.0f, x*2.0f, y ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*4.0f, x*1.0f, y ) ); + } + + void Base::DrawCheck( Gwen::Rect rect ) + { + float x = (rect.w / 5.0f); + float y = (rect.h / 5.0f); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*0.0f, rect.y + y*3.0f, x*2, y*2 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*1.0f, rect.y + y*4.0f, x*2, y*2 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*2.0f, rect.y + y*3.0f, x*2, y*2 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*3.0f, rect.y + y*1.0f, x*2, y*2 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + x*4.0f, rect.y + y*0.0f, x*2, y*2 ) ); + } + + void Base::DrawTreeNode( Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot ) + { + GetRender()->SetDrawColor( Colors.Tree.Lines ); + + if ( !bIsRoot ) + GetRender()->DrawFilledRect( Gwen::Rect( 8, iHalfWay, 16-9, 1 ) ); + + if ( !bOpen ) return; + + GetRender()->DrawFilledRect( Gwen::Rect( 14 + 7, iLabelHeight+1, 1, iLastBranch + iHalfWay - iLabelHeight ) ); + } + + void Base::DrawPropertyTreeNode( Controls::Base* control, int BorderLeft, int BorderTop ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + m_Render->SetDrawColor( Colors.Properties.Border ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x, rect.y, BorderLeft, rect.h ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x + BorderLeft, rect.y, rect.w - BorderLeft, BorderTop ) ); + } + + void Base::DrawPropertyRow( Controls::Base* control, int iWidth, bool bBeingEdited, bool bHovered ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + if ( bBeingEdited ) m_Render->SetDrawColor( Colors.Properties.Column_Selected ); + else if ( bHovered ) m_Render->SetDrawColor( Colors.Properties.Column_Hover ); + else m_Render->SetDrawColor( Colors.Properties.Column_Normal ); + + m_Render->DrawFilledRect( Gwen::Rect( 0, rect.y, iWidth, rect.h ) ); + + if ( bBeingEdited ) m_Render->SetDrawColor( Colors.Properties.Line_Selected ); + else if ( bHovered ) m_Render->SetDrawColor( Colors.Properties.Line_Hover ); + else m_Render->SetDrawColor( Colors.Properties.Line_Normal ); + + m_Render->DrawFilledRect( Gwen::Rect( iWidth, rect.y, 1, rect.h ) ); + + rect.y += rect.h-1; + rect.h = 1; + + m_Render->DrawFilledRect( rect ); + } + } +} diff --git a/lib/gwen/gwen_skin.h b/lib/gwen/gwen_skin.h new file mode 100644 index 0000000..91d55c8 --- /dev/null +++ b/lib/gwen/gwen_skin.h @@ -0,0 +1,266 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_SKIN_H +#define GWEN_SKIN_H + +#include "gwen_baserender.h" +#include "gwen_font.h" + +namespace Gwen +{ + namespace Controls + { + class Base; + } + + namespace Skin + { + namespace Symbol + { + static const unsigned char None = 0; + static const unsigned char ArrowRight = 1; + static const unsigned char Check = 2; + static const unsigned char Dot = 3; + } + + namespace Panel + { + static const unsigned char Normal = 0; + static const unsigned char Bright = 1; + static const unsigned char Dark = 2; + static const unsigned char Highlight = 3; + } + + class GWEN_EXPORT Base + { + public: + + Base( Gwen::Renderer::Base* renderer = NULL ) + { + m_DefaultFont.facename = "Arial"; + m_DefaultFont.size = 10.0f; + m_Render = renderer; + } + + virtual ~Base() + { + ReleaseFont( &m_DefaultFont ); + } + + virtual void ReleaseFont( Gwen::Font* fnt ) + { + if ( !fnt ) return; + if ( !m_Render ) return; + + m_Render->FreeFont( fnt ); + } + + virtual void DrawGenericPanel( Controls::Base* control ) = 0; + virtual void DrawPanel( Controls::Base* control, unsigned char iPanelType = Gwen::Skin::Panel::Normal ) = 0; + + virtual void DrawButton( Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) = 0; + virtual void DrawTabButton( Controls::Base* control, bool bActive, int dir ) = 0; + virtual void DrawTabControl( Controls::Base* control ) = 0; + virtual void DrawTabTitleBar( Controls::Base* control ) = 0; + + + virtual void DrawMenuItem( Controls::Base* control, bool bSubmenuOpen, bool bChecked ) = 0; + virtual void DrawMenuStrip( Controls::Base* control ) = 0; + virtual void DrawMenu( Controls::Base* control, bool bPaddingDisabled ) = 0; + virtual void DrawMenuRightArrow( Controls::Base* control ) = 0; + + virtual void DrawRadioButton(Controls::Base* control, bool bSelected, bool bDepressed) = 0; + virtual void DrawCheckBox( Controls::Base* control, bool bSelected, bool bDepressed ) = 0; + virtual void DrawGroupBox( Controls::Base* control, int textStart, int textHeight, int textWidth ) = 0; + virtual void DrawTextBox( Controls::Base* control ) = 0; + + virtual void DrawWindow( Controls::Base* control, int topHeight, bool inFocus ) = 0; + virtual void DrawWindowCloseButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) = 0; + virtual void DrawWindowMaximizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled, bool bMaximized ) = 0; + virtual void DrawWindowMinimizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) = 0; + + + virtual void DrawHighlight( Controls::Base* control ) = 0; + virtual void DrawStatusBar( Controls::Base* control ) = 0; + + virtual void DrawShadow( Controls::Base* control ) = 0; + virtual void DrawScrollBarBar( Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal ) = 0; + virtual void DrawScrollBar( Controls::Base* control, bool isHorizontal, bool bDepressed ) = 0; + virtual void DrawScrollButton( Controls::Base* control, int iDirection, bool bDepressed, bool bHovered, bool bDisabled ) = 0; + virtual void DrawProgressBar( Controls::Base* control, bool isHorizontal, float progress) = 0; + + virtual void DrawListBox( Controls::Base* control ) = 0; + virtual void DrawListBoxLine( Controls::Base* control, bool bSelected, bool bEven ) = 0; + + virtual void DrawSlider( Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize ) = 0; + virtual void DrawSlideButton( Gwen::Controls::Base* control, bool bDepressed, bool bHorizontal ) = 0; + + virtual void DrawComboBox( Controls::Base* control, bool bIsDown, bool bIsMenuOpen ) = 0; + virtual void DrawComboDownArrow( Gwen::Controls::Base* control, bool bHovered, bool bDown, bool bOpen, bool bDisabled ) = 0; + virtual void DrawKeyboardHighlight( Controls::Base* control, const Gwen::Rect& rect, int offset ) = 0; + virtual void DrawToolTip( Controls::Base* control ) = 0; + + virtual void DrawNumericUpDownButton( Controls::Base* control, bool bDepressed, bool bUp ) = 0; + + virtual void DrawTreeButton( Controls::Base* control, bool bOpen ) = 0; + virtual void DrawTreeControl( Controls::Base* control ) = 0; + virtual void DrawTreeNode( Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot ); + + virtual void DrawPropertyRow( Controls::Base* control, int iWidth, bool bBeingEdited, bool bHovered ); + virtual void DrawPropertyTreeNode( Controls::Base* control, int BorderLeft, int BorderTop ); + virtual void DrawColorDisplay( Controls::Base* control, Gwen::Color color ) = 0; + virtual void DrawModalControl( Controls::Base* control ) = 0; + virtual void DrawMenuDivider( Controls::Base* control ) = 0; + + virtual void DrawCategoryHolder( Controls::Base* ctrl ) = 0; + virtual void DrawCategoryInner( Controls::Base* ctrl, bool bCollapsed ) = 0; + + + virtual void SetRender( Gwen::Renderer::Base* renderer ) + { + m_Render = renderer; + } + virtual Gwen::Renderer::Base* GetRender() + { + return m_Render; + } + + virtual void DrawArrowDown( Gwen::Rect rect ); + virtual void DrawArrowUp( Gwen::Rect rect ); + virtual void DrawArrowLeft( Gwen::Rect rect ); + virtual void DrawArrowRight( Gwen::Rect rect ); + virtual void DrawCheck( Gwen::Rect rect ); + + + struct + { + struct Window_t + { + Gwen::Color TitleActive; + Gwen::Color TitleInactive; + + } Window; + + struct Label_t + { + Gwen::Color Default; + Gwen::Color Bright; + Gwen::Color Dark; + Gwen::Color Highlight; + + } Label; + + struct Tree_t + { + Gwen::Color Lines; + Gwen::Color Normal; + Gwen::Color Hover; + Gwen::Color Selected; + + } Tree; + + struct Properties_t + { + Gwen::Color Line_Normal; + Gwen::Color Line_Selected; + Gwen::Color Line_Hover; + Gwen::Color Column_Normal; + Gwen::Color Column_Selected; + Gwen::Color Column_Hover; + Gwen::Color Label_Normal; + Gwen::Color Label_Selected; + Gwen::Color Label_Hover; + Gwen::Color Border; + Gwen::Color Title; + + } Properties; + + struct Button_t + { + Gwen::Color Normal; + Gwen::Color Hover; + Gwen::Color Down; + Gwen::Color Disabled; + + } Button; + + struct Tab_t + { + struct Active_t + { + Gwen::Color Normal; + Gwen::Color Hover; + Gwen::Color Down; + Gwen::Color Disabled; + } Active; + + struct Inactive_t + { + Gwen::Color Normal; + Gwen::Color Hover; + Gwen::Color Down; + Gwen::Color Disabled; + } Inactive; + + } Tab; + + struct Category_t + { + Gwen::Color Header; + Gwen::Color Header_Closed; + + struct Line_t + { + Gwen::Color Text; + Gwen::Color Text_Hover; + Gwen::Color Text_Selected; + Gwen::Color Button; + Gwen::Color Button_Hover; + Gwen::Color Button_Selected; + } Line; + + struct LineAlt_t + { + Gwen::Color Text; + Gwen::Color Text_Hover; + Gwen::Color Text_Selected; + Gwen::Color Button; + Gwen::Color Button_Hover; + Gwen::Color Button_Selected; + } LineAlt; + + } Category; + + Gwen::Color ModalBackground; + Gwen::Color TooltipText; + + } Colors; + + + public: + + virtual Gwen::Font* GetDefaultFont() + { + return &m_DefaultFont; + } + + virtual void SetDefaultFont( const Gwen::String& strFacename, float fSize = 10.0f ) + { + m_DefaultFont.facename = strFacename; + m_DefaultFont.size = fSize; + } + + protected: + + Gwen::Font m_DefaultFont; + Gwen::Renderer::Base* m_Render; + + }; + }; +} +#endif diff --git a/lib/gwen/gwen_structures.h b/lib/gwen/gwen_structures.h new file mode 100644 index 0000000..a5227b0 --- /dev/null +++ b/lib/gwen/gwen_structures.h @@ -0,0 +1,244 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifdef _MSC_VER +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4251 ) +#endif +#ifndef GWEN_STRUCTURES_H +#define GWEN_STRUCTURES_H + +#include "gwen_exports.h" +#include + +namespace Gwen +{ + namespace Controls + { + class Base; + class Canvas; + } + + namespace CursorType + { + static const unsigned char Normal = 0; + static const unsigned char Beam = 1; + static const unsigned char SizeNS = 2; + static const unsigned char SizeWE = 3; + static const unsigned char SizeNWSE = 4; + static const unsigned char SizeNESW = 5; + static const unsigned char SizeAll = 6; + static const unsigned char No = 7; + static const unsigned char Wait = 8; + static const unsigned char Finger = 9; + + static const unsigned char Count = 10; + } + + typedef stl::string String; + + struct GWEN_EXPORT Margin + { + Margin( int left_ = 0, int top_ = 0, int right_ = 0, int bottom_ = 0 ) + { + this->top = top_; + this->bottom = bottom_; + this->left = left_; + this->right = right_; + } + + Margin operator +( const Margin& margin ) const + { + Margin m; + + m.top = top + margin.top; + m.bottom = bottom + margin.bottom; + m.left = left + margin.left; + m.right = right + margin.right; + + return m; + } + + int top, bottom, left, right; + }; + + + typedef Margin Padding; + + + struct GWEN_EXPORT Rect + { + Rect( int x_ = 0, int y_ = 0, int w_ = 0, int h_ = 0 ) + { + this->x = x_; + this->y = y_; + this->w = w_; + this->h = h_; + } + + Rect operator +( const Rect& rct ) const + { + Rect m; + + m.x = x + rct.x; + m.y = y + rct.y; + m.w = w + rct.w; + m.h = h + rct.h; + + return m; + } + + int x, y, w, h; + }; + + + struct GWEN_EXPORT Point + { + Point(int x_ = 0, int y_ = 0) + { + this->x = x_; + this->y = y_; + } + + void operator +=( const Point& p ) + { + x += p.x; + y += p.y; + } + + Point operator +( const Point& p ) const + { + return Point( x + p.x, p.y + y ); + } + + void operator -=( const Point& p ) + { + x -= p.x; + y -= p.y; + } + + Point operator -( const Point& p ) const + { + return Point( x - p.x, y - p.y ); + } + + int x, y; + }; + + struct GWEN_EXPORT HSV + { + float h; + float s; + float v; + }; + + + struct GWEN_EXPORT Color + { + Color( unsigned char r_ = 255, unsigned char g_ = 255, unsigned char b_ = 255, unsigned char a_ = 255 ) + { + this->r = r_; + this->g = g_; + this->b = b_; + this->a = a_; + } + + void operator = ( Color c ) + { + this->r = c.r; + this->g = c.g; + this->b = c.b; + this->a = c.a; + } + + void operator += ( Color c ) + { + this->r += c.r; + this->g += c.g; + this->b += c.b; + this->a += c.a; + } + + void operator -= ( Color c ) + { + this->r -= c.r; + this->g -= c.g; + this->b -= c.b; + this->a -= c.a; + } + + void operator *= ( float f ) + { + this->r *= f; + this->g *= f; + this->b *= f; + this->a *= f; + } + + Color operator *( float f ) + { + return Color( + (float)this->r*f, + (float)this->g*f, + (float)this->b*f, + (float)this->a*f + ); + } + + Color operator - ( Color c ) + { + return Color( + this->r - c.r, + this->g - c.g, + this->b - c.b, + this->a - c.a + ); + } + + Color operator + ( Color c ) + { + return Color( + this->r + c.r, + this->g + c.g, + this->b + c.b, + this->a + c.a + ); + } + + bool operator ==( const Color& c ) const + { + return c.r==r && c.g==g && c.b==b && c.a==a; + } + + + unsigned char r, g, b, a; + }; + + + namespace DragAndDrop + { + struct GWEN_EXPORT Package + { + Package() + { + userdata = NULL; + draggable = false; + drawcontrol = NULL; + holdoffset = Gwen::Point( 0, 0 ); + } + + String name; + void* userdata; + bool draggable; + + Gwen::Controls::Base* drawcontrol; + Gwen::Point holdoffset; + }; + } + +} +#endif diff --git a/lib/gwen/gwen_textobject.h b/lib/gwen/gwen_textobject.h new file mode 100644 index 0000000..9ae7772 --- /dev/null +++ b/lib/gwen/gwen_textobject.h @@ -0,0 +1,71 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_TEXTOBJECT_H +#define GWEN_TEXTOBJECT_H + +#include "gwen_utility.h" + +namespace Gwen +{ + /* + + TextObjects can be either a UnicodeString or a String + + Just makes things easier instead of having a function taking both. + + */ + class TextObject + { + public: + + TextObject(){} + + TextObject( const Gwen::String& text ) + { + m_String = text; + } + + TextObject( const char* text ) + { + m_String = text; + } + + operator const Gwen::String&(){ return m_String; } + + void operator = ( const char* str ) + { + m_String = str; + } + + void operator = ( const Gwen::String& str ) + { + m_String = str; + } + + bool operator == ( const TextObject& to ) const + { + return m_String == to.m_String; + } + + const Gwen::String& Get() const + { + return m_String; + } + + const char* c_str() const + { + return m_String.c_str(); + } + + + int length() const { return m_String.length(); } + + Gwen::String m_String; + }; +} +#endif diff --git a/lib/gwen/gwen_texture.h b/lib/gwen/gwen_texture.h new file mode 100644 index 0000000..03d0652 --- /dev/null +++ b/lib/gwen/gwen_texture.h @@ -0,0 +1,62 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#pragma once +#ifndef GWEN_TEXTURE_H +#define GWEN_TEXTURE_H + +#include + +#include "gwen.h" +#include "gwen_baserender.h" + +namespace Gwen +{ + // + // Texture + // + struct Texture + { + typedef stl::list List; + + TextObject name; + void* data; + bool failed; + int width; + int height; + + Texture() + { + data = NULL; + width = 4; + height = 4; + failed = false; + } + + ~Texture() + { + } + + void Load( const TextObject& str, Gwen::Renderer::Base* render ) + { + name = str; + Gwen::Debug::AssertCheck( render != NULL, "No renderer!" ); + render->LoadTexture( this ); + } + + void Release( Gwen::Renderer::Base* render ) + { + render->FreeTexture( this ); + } + + bool FailedToLoad() const + { + return failed; + } + }; + +} +#endif diff --git a/lib/gwen/gwen_tooltip.cpp b/lib/gwen/gwen_tooltip.cpp new file mode 100644 index 0000000..069f950 --- /dev/null +++ b/lib/gwen/gwen_tooltip.cpp @@ -0,0 +1,66 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#include "gwen_tooltip.h" +#include "gwen_utility.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +namespace ToolTip +{ + Base* g_ToolTip = NULL; + + GWEN_EXPORT bool TooltipActive() + { + return g_ToolTip != NULL; + } + + void Enable( Controls::Base* pControl ) + { + if ( !pControl->GetToolTip() ) + return; + + g_ToolTip = pControl; + } + + void Disable( Controls::Base* pControl ) + { + if ( g_ToolTip == pControl ) + { + g_ToolTip = NULL; + } + } + + void RenderToolTip( Skin::Base* skin ) + { + if ( !g_ToolTip ) return; + + Gwen::Renderer::Base* render = skin->GetRender(); + + Gwen::Point pOldRenderOffset = render->GetRenderOffset(); + Gwen::Point MousePos = Input::GetMousePosition(); + Gwen::Rect Bounds = g_ToolTip->GetToolTip()->GetBounds(); + + Gwen::Rect rOffset = Gwen::Rect( MousePos.x - Bounds.w * 0.5f, MousePos.y - Bounds.h - 10, Bounds.w, Bounds.h ); + rOffset = Utility::ClampRectToRect( rOffset, g_ToolTip->GetCanvas()->GetBounds() ); + + //Calculate offset on screen bounds + render->AddRenderOffset( rOffset ); + render->EndClip(); + + skin->DrawToolTip( g_ToolTip->GetToolTip() ); + g_ToolTip->GetToolTip()->DoRender( skin ); + + render->SetRenderOffset( pOldRenderOffset ); + } + + void ControlDeleted( Controls::Base* pControl ) + { + Disable( pControl ); + } +} diff --git a/lib/gwen/gwen_tooltip.h b/lib/gwen/gwen_tooltip.h new file mode 100644 index 0000000..b8fa911 --- /dev/null +++ b/lib/gwen/gwen_tooltip.h @@ -0,0 +1,31 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + + +#pragma once +#ifndef GWEN_TOOLTIP_H +#define GWEN_TOOLTIP_H + +#include "controls/gwen_base.h" +#include "gwen.h" +#include "gwen_skin.h" + +using namespace Gwen; +using namespace Gwen::Controls; + +namespace ToolTip +{ + GWEN_EXPORT bool TooltipActive(); + + GWEN_EXPORT void Enable ( Controls::Base* pControl ); + GWEN_EXPORT void Disable ( Controls::Base* pControl ); + + GWEN_EXPORT void ControlDeleted ( Controls::Base* pControl ); + + GWEN_EXPORT void RenderToolTip ( Skin::Base* skin ); +} + +#endif diff --git a/lib/gwen/gwen_userdata.h b/lib/gwen/gwen_userdata.h new file mode 100644 index 0000000..fe03c8a --- /dev/null +++ b/lib/gwen/gwen_userdata.h @@ -0,0 +1,112 @@ +#pragma once +#ifndef GWEN_USERDATA_H +#define GWEN_USERDATA_H + +namespace Gwen +{ + /* + + Allows you to store multiple and various user data + + // + // Valid + // + UserDataStorage.Set( 100.0f ); + UserDataStorage.Get(); + + // + // Invalid - didn't Add a float type! + // + UserDataStorage.Set( 100 ); + UserDataStorage.Get(); + + // + // You can pass structs as long as they can be copied safely. + // + UserDataStorage.Set( mystruct ); + UserDataStorage.Get(); + + // + // If you pass a pointer then whatever it's pointing to + // should be valid for the duration. And it won't be freed. + // + UserDataStorage.Set( &mystruct ); + UserDataStorage.Get(); + + */ + class UserDataStorage + { + struct ValueBase + { + virtual void DeleteThis() = 0; + }; + + template struct Value : public ValueBase + { + T val; + + Value( const T& v ) + { + val = v; + } + + virtual void DeleteThis() + { + delete this; + } + }; + + public: + + UserDataStorage() + { + } + + ~UserDataStorage() + { + stl::map< Gwen::String, void*>::iterator it = m_List.begin(); + stl::map< Gwen::String, void*>::iterator itEnd = m_List.end(); + + while( it != itEnd ) + { + ((ValueBase*)it->second)->DeleteThis(); + ++it; + } + } + + template + void Set( const Gwen::String& str, const T& var ) + { + Value* val = NULL; + + stl::map< Gwen::String, void*>::iterator it = m_List.find( str ); + if ( it != m_List.end() ) + { + ((Value*)it->second)->val = var; + } + else + { + val = new Value( var ); + m_List[ str ] = (void*) val; + } + + }; + + bool Exists( const Gwen::String& str ) + { + return m_List.find( str ) != m_List.end(); + }; + + template + T& Get( const Gwen::String& str ) + { + Value* v = (Value*) m_List[ str ]; + return v->val; + } + + stl::map< Gwen::String, void*> m_List; + }; + +}; + +#endif diff --git a/lib/gwen/gwen_utility.cpp b/lib/gwen/gwen_utility.cpp new file mode 100644 index 0000000..f262b98 --- /dev/null +++ b/lib/gwen/gwen_utility.cpp @@ -0,0 +1,142 @@ +/* + GWEN + Copyright (c) 2010 Facepunch Studios + See license in Gwen.h +*/ + +#include "gwen_tooltip.h" +#include "gwen_utility.h" + +#include +#include + +using namespace Gwen; + +#ifdef _MSC_VER + #pragma warning(disable:4267)// conversion from 'size_t' to 'int', possible loss of data +#endif + +#ifdef __MINGW32__ + #undef vswprintf + #define vswprintf _vsnwprintf +#endif + +String Gwen::Utility::Format( const char* fmt, ... ) +{ + char strOut[ 4096 ]; + + va_list s; + va_start( s, fmt ); + vsnprintf( strOut, sizeof(strOut), fmt, s ); + va_end(s); + + String str = strOut; + return str; +} + + + +void Gwen::Utility::Strings::Split( const Gwen::String& str, const Gwen::String& seperator, Strings::List& outbits, bool bLeave ) +{ + int iOffset = 0; + int iLength = str.length(); + int iSepLen = seperator.length(); + + size_t i = str.find( seperator, 0 ); + while ( i != stl::string::npos ) + { + outbits.push_back( str.substr( iOffset, i-iOffset ) ); + iOffset = i + iSepLen; + + i = str.find( seperator, iOffset ); + if ( bLeave ) iOffset -= iSepLen; + } + + outbits.push_back( str.substr( iOffset, iLength-iOffset ) ); +} + +int Gwen::Utility::Strings::To::Int( const Gwen::String& str ) +{ + if ( str == "" ) return 0; + return atoi( str.c_str() ); +} + +float Gwen::Utility::Strings::To::Float( const Gwen::String& str ) +{ + if ( str == "" ) return 0.0f; + return (float)atof( str.c_str() ); +} + +bool Gwen::Utility::Strings::To::Bool( const Gwen::String& str ) +{ + if ( str.size() == 0 ) return false; + if ( str[0] == 'T' || str[0] == 't' || str[0] == 'y' || str[0] == 'Y' ) return true; + if ( str[0] == 'F' || str[0] == 'f' || str[0] == 'n' || str[0] == 'N' ) return false; + if ( str[0] == '0' ) return false; + return true; +} + +bool Gwen::Utility::Strings::To::Floats( const Gwen::String& str, float* f, size_t iCount ) +{ + Strings::List lst; + Strings::Split( str, " ", lst ); + if ( lst.size() != iCount ) return false; + + for ( size_t i=0; i 0 && W.substr( 0, iPos ) != H.substr( 0, iPos ) ) + return false; + + // Second half matches + if ( iPos != W.length()-1 ) + { + String strEnd = W.substr( iPos+1, W.length() ); + + if ( strEnd != H.substr( H.length() - strEnd.length(), H.length() ) ) + return false; + } + + return true; +} + + + +void Gwen::Utility::Strings::ToUpper( Gwen::String& str ) +{ + stl::transform( str.begin(), str.end(), str.begin(), toupper ); +} + +void Gwen::Utility::Strings::Strip( Gwen::String& str, const Gwen::String& chars ) +{ + Gwen::String Source = str; + str = ""; + + for ( unsigned int i =0; i +#include +#include "gwen_structures.h" + +namespace Gwen +{ + class TextObject; + + namespace Utility + { + template + const T& Max( const T& x, const T& y ) + { + if ( y < x ) return x; + return y; + } + + template + const T& Min( const T& x, const T& y ) + { + if ( y > x ) return x; + return y; + } + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning( disable : 4996 ) +#endif + + template void Replace( T& str, const T& strFind, const T& strReplace ) + { + size_t pos = 0; + while( (pos = str.find(strFind, pos) ) != T::npos ) + { + str.replace( pos, strFind.length(), strReplace ); + pos += strReplace.length(); + } + } + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + + // NOTE: commented out and replaced with the below overloads + // to remove a dependency on std::ostringstream + //template + //String ToString( const T& object ) + //{ + // std::ostringstream os; + // os << object; + // return os.str(); + //} + + ////// + inline String ToString( int object ) + { + char temp[22]; // good enough for a 64 bit number (including negative) + snprintf(temp, 22, "%d", object); + String result = temp; + return result; + } + + inline String ToString( unsigned int object ) + { + char temp[22]; // good enough for a 64 bit number + snprintf(temp, 22, "%u", object); + String result = temp; + return result; + } + + inline String ToString( float object ) + { + char temp[22]; // to be honest, I don't know if this is good enough. let's hope so... at least snprintf is being used :) + snprintf(temp, 22, "%f", object); + String result = temp; + return result; + } + ////// + + inline Gwen::Rect ClampRectToRect( Gwen::Rect inside, Gwen::Rect outside, bool clampSize = false ) + { + if ( inside.x < outside.x ) + inside.x = outside.x; + + if ( inside.y < outside.y ) + inside.y = outside.y; + + if ( inside.x + inside.w > outside.x + outside.w ) + { + if ( clampSize ) + inside.w = outside.w; + else + inside.x = outside.x + outside.w - inside.w; + } + if ( inside.y + inside.h > outside.y + outside.h ) + { + if ( clampSize ) + inside.h = outside.h; + else + inside.y = outside.w + outside.h - inside.h; + } + + return inside; + } + + GWEN_EXPORT String Format( const char* fmt, ... ); + + namespace Strings + { + typedef stl::vector List; + + GWEN_EXPORT void Split( const Gwen::String& str, const Gwen::String& seperator, Strings::List& outbits, bool bLeaveSeperators = false ); + GWEN_EXPORT bool Wildcard( const Gwen::TextObject& strWildcard, const Gwen::TextObject& strHaystack ); + + GWEN_EXPORT void ToUpper( Gwen::String& str ); + GWEN_EXPORT void Strip( Gwen::String& str, const Gwen::String& chars ); + + template + T TrimLeft( const T& str, const T& strChars ) + { + T outstr = str; + outstr.erase( 0, outstr.find_first_not_of( strChars ) ); + return outstr; + } + + namespace To + { + GWEN_EXPORT bool Bool( const Gwen::String& str ); + GWEN_EXPORT int Int( const Gwen::String& str ); + GWEN_EXPORT float Float( const Gwen::String& str ); + GWEN_EXPORT bool Floats( const Gwen::String& str, float* f, size_t iCount ); + } + } + } + + + +} +#endif diff --git a/lib/gwen/gwen_windowprovider.h b/lib/gwen/gwen_windowprovider.h new file mode 100644 index 0000000..b3d2762 --- /dev/null +++ b/lib/gwen/gwen_windowprovider.h @@ -0,0 +1,16 @@ +#pragma once +#ifndef GWEN_WINDOW_PROVIDER_H +#define GWEN_WINDOW_PROVIDER_H + +namespace Gwen +{ + class WindowProvider + { + public: + + virtual void* GetWindow() = 0; + }; + +} + +#endif diff --git a/lib/gwen/platforms/gwen_null.cpp b/lib/gwen/platforms/gwen_null.cpp new file mode 100644 index 0000000..e8a77c9 --- /dev/null +++ b/lib/gwen/platforms/gwen_null.cpp @@ -0,0 +1,107 @@ +/* + GWEN + Copyright (c) 2012 Facepunch Studios + See license in Gwen.h +*/ + +#include "../gwen_macros.h" +#include "../gwen_platform.h" + +#include + +static Gwen::String gs_ClipboardEmulator; + +void Gwen::Platform::Sleep( unsigned int iMS ) +{ + // TODO. +} + +void Gwen::Platform::SetCursor( unsigned char iCursor ) +{ + // No platform independent way to do this +} + +Gwen::String Gwen::Platform::GetClipboardText() +{ + return gs_ClipboardEmulator; +} + +bool Gwen::Platform::SetClipboardText( const Gwen::String& str ) +{ + gs_ClipboardEmulator = str; + return true; +} + +float Gwen::Platform::GetTimeInSeconds() +{ + float fSeconds = (float) clock() / (float)CLOCKS_PER_SEC; + return fSeconds; +} + +bool Gwen::Platform::FileOpen( const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ) +{ + // No platform independent way to do this. + // Ideally you would open a system dialog here + + return false; +} + +bool Gwen::Platform::FileSave( const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Gwen::Event::Handler::FunctionWithInformation fnCallback ) +{ + // No platform independent way to do this. + // Ideally you would open a system dialog here + + return false; +} + +bool Gwen::Platform::FolderOpen( const String& Name, const String& StartPath, Gwen::Event::Handler* pHandler, Event::Handler::FunctionWithInformation fnCallback ) +{ + return false; +} + +void* Gwen::Platform::CreatePlatformWindow( int x, int y, int w, int h, const Gwen::String& strWindowTitle ) +{ + return NULL; +} + +void Gwen::Platform::DestroyPlatformWindow( void* pPtr ) +{ + +} + +void Gwen::Platform::MessagePump( void* pWindow, Gwen::Controls::Canvas* ptarget ) +{ + +} + +void Gwen::Platform::SetBoundsPlatformWindow( void* pPtr, int x, int y, int w, int h ) +{ + +} + +void Gwen::Platform::SetWindowMaximized( void* pPtr, bool bMax, Gwen::Point& pNewPos, Gwen::Point& pNewSize ) +{ + +} + +void Gwen::Platform::SetWindowMinimized( void* pPtr, bool bMinimized ) +{ + +} + +bool Gwen::Platform::HasFocusPlatformWindow( void* pPtr ) +{ + return true; +} + +void Gwen::Platform::GetDesktopSize( int& w, int &h ) +{ + w = 1024; + h = 768; +} + +void Gwen::Platform::GetCursorPos( Gwen::Point &po ) +{ + +} + diff --git a/lib/gwen/skins/gwen_simple.h b/lib/gwen/skins/gwen_simple.h new file mode 100644 index 0000000..f9e758c --- /dev/null +++ b/lib/gwen/skins/gwen_simple.h @@ -0,0 +1,738 @@ +#pragma once +#ifndef GWEN_SKINS_SIMPLE_H +#define GWEN_SKINS_SIMPLE_H + +#include "../gwen_skin.h" +#include "../gwen.h" +#include "../controls/gwen_base.h" + +namespace Gwen +{ + namespace Skin + { + class Simple : public Gwen::Skin::Base + { + public: + + Simple( Gwen::Renderer::Base* renderer ) : Gwen::Skin::Base( renderer ) + { + + } + + Gwen::Color m_colBorderColor; + Gwen::Color m_colControlOutlineLight; + Gwen::Color m_colControlOutlineLighter; + Gwen::Color m_colBG; + Gwen::Color m_colBGDark; + Gwen::Color m_colControl; + Gwen::Color m_colControlBorderHighlight; + Gwen::Color m_colControlDarker; + Gwen::Color m_colControlOutlineNormal; + Gwen::Color m_colControlBright; + Gwen::Color m_colControlDark; + Gwen::Color m_colHighlightBG; + Gwen::Color m_colHighlightBorder; + Gwen::Color m_colToolTipBackground; + Gwen::Color m_colToolTipBorder; + Gwen::Color m_colModal; + + Simple() + { + m_colBorderColor = Gwen::Color( 80, 80, 80, 255 ); + m_colBG = Gwen::Color( 248, 248, 248, 255 ); + m_colBGDark = Gwen::Color( 235, 235, 235, 255 ); + + m_colControl = Gwen::Color( 240, 240, 240, 255 ); + m_colControlBright = Gwen::Color( 255, 255, 255, 255 ); + m_colControlDark = Gwen::Color( 214, 214, 214, 255 ); + m_colControlDarker = Gwen::Color( 180, 180, 180, 255 ); + + m_colControlOutlineNormal = Gwen::Color( 112, 112, 112, 255 ); + m_colControlOutlineLight = Gwen::Color( 144, 144, 144, 255 ); + m_colControlOutlineLighter = Gwen::Color( 210, 210, 210, 255 ); + + m_colHighlightBG = Gwen::Color( 192, 221, 252, 255 ); + m_colHighlightBorder = Gwen::Color( 51, 153, 255, 255 ); + + m_colToolTipBackground = Gwen::Color( 255, 255, 225, 255 ); + m_colToolTipBorder = Gwen::Color( 0, 0, 0, 255 ); + + m_colModal = Gwen::Color( 25, 25, 25, 150 ); + + m_DefaultFont.facename = "Microsoft Sans Serif"; + m_DefaultFont.size = 11; + } + + virtual void DrawGenericPanel( Controls::Base* control ) + { + // TODO. + } + + virtual void DrawPanel( Controls::Base* control, unsigned char iPanelType = Gwen::Skin::Panel::Normal ) + { + // TODO. + } + + virtual void DrawButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + int w = control->Width(); + int h = control->Height(); + + DrawButton( w, h, bDepressed, bHovered ); + } + + virtual void DrawWindowCloseButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + // TODO. + DrawButton( control, bDepressed, bHovered, bDisabled ); + } + + virtual void DrawWindowMaximizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled, bool bMaximized ) + { + // TODO. + DrawButton( control, bDepressed, bHovered, bDisabled ); + } + + virtual void DrawWindowMinimizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + // TODO. + DrawButton( control, bDepressed, bHovered, bDisabled ); + } + + virtual void DrawMenuItem( Gwen::Controls::Base* control, bool bSubmenuOpen, bool bChecked ) + { + if ( bSubmenuOpen || control->IsHovered() ) + { + m_Render->SetDrawColor( m_colHighlightBG ); + m_Render->DrawFilledRect( control->GetRenderBounds() ); + + m_Render->SetDrawColor( m_colHighlightBorder ); + m_Render->DrawLinedRect( control->GetRenderBounds() ); + } + + Gwen::Rect rect = control->GetRenderBounds(); + if ( bChecked ) + { + m_Render->SetDrawColor( Color( 0, 0, 0, 255) ); + + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + DrawCheck( r ); + } + } + + virtual void DrawMenuStrip( Gwen::Controls::Base* control ) + { + int w = control->Width(); + int h = control->Height(); + + m_Render->SetDrawColor( Gwen::Color( 246, 248, 252, 255 ) ); + m_Render->DrawFilledRect( Gwen::Rect( 0, 0, w, h ) ); + + m_Render->SetDrawColor( Gwen::Color( 218, 224, 241, 150 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( 0, h*0.4f, w, h*0.6f ) ); + m_Render->DrawFilledRect( Gwen::Rect( 0, h*0.5f, w, h*0.5f ) ); + + } + + virtual void DrawMenu( Gwen::Controls::Base* control, bool bPaddingDisabled ) + { + int w = control->Width(); + int h = control->Height(); + + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawFilledRect( Gwen::Rect( 0, 0, w, h ) ); + + if ( !bPaddingDisabled ) + { + m_Render->SetDrawColor( m_colControl ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 0, 22, h ) ); + } + + m_Render->SetDrawColor( m_colControlOutlineNormal ); + m_Render->DrawLinedRect( Gwen::Rect( 0, 0, w, h ) ); + } + + virtual void DrawShadow( Gwen::Controls::Base* control ) + { + int w = control->Width(); + int h = control->Height(); + + int x = 4; + int y = 6; + + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 10 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( x, y, w, h ) ); + x+=2; + m_Render->DrawFilledRect( Gwen::Rect( x, y, w, h ) ); + y+=2; + m_Render->DrawFilledRect( Gwen::Rect( x, y, w, h ) ); + + } + + virtual void DrawButton( int w, int h, bool bDepressed, bool bHovered, bool bSquared = false ) + { + if ( bDepressed ) m_Render->SetDrawColor( m_colControlDark ); + else if ( bHovered )m_Render->SetDrawColor( m_colControlBright ); + else m_Render->SetDrawColor( m_colControl ); + + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, w-2, h-2 ) ); + + if ( bDepressed ) m_Render->SetDrawColor( m_colControlDark ); + else if ( bHovered )m_Render->SetDrawColor( m_colControl ); + else m_Render->SetDrawColor( m_colControlDark ); + + m_Render->DrawFilledRect( Gwen::Rect( 1, h*0.5, w-2, h*0.5-2 ) ); + + if ( !bDepressed ) + { + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 1, 1, w-2, h-2 ), bSquared ); + } + else + { + m_Render->SetDrawColor( m_colControlDarker ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 1, 1, w-2, h-2 ), bSquared ); + } + + // Border + m_Render->SetDrawColor( m_colControlOutlineNormal ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 0, 0, w, h ), bSquared ); + } + + virtual void DrawRadioButton( Gwen::Controls::Base* control, bool bSelected, bool bDepressed) + { + Gwen::Rect rect = control->GetRenderBounds(); + + // Inside colour + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 220, 242, 254, 255 ) ); + else m_Render->SetDrawColor( m_colControlBright ); + + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-2 ) ); + + // Border + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 85, 130, 164, 255 ) ); + else m_Render->SetDrawColor( m_colControlOutlineLight ); + + m_Render->DrawShavedCornerRect( rect ); + + m_Render->SetDrawColor( Gwen::Color( 0, 50, 60, 15 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w-4, rect.h-4 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w*0.3f, rect.h-4 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w-4, rect.h*0.3f ) ); + + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 121, 198, 249, 255 ) ); + else m_Render->SetDrawColor( Gwen::Color( 0, 50, 60, 50 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+3, 1, rect.h-5 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+3, rect.y+2, rect.w-5, 1 ) ); + + + if ( bSelected ) + { + m_Render->SetDrawColor( Gwen::Color( 40, 230, 30, 255 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w -4, rect.h-4 ) ); + } + } + + + virtual void DrawCheckBox( Gwen::Controls::Base* control, bool bSelected, bool bDepressed) + { + Gwen::Rect rect = control->GetRenderBounds(); + + // Inside colour + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 220, 242, 254, 255 ) ); + else m_Render->SetDrawColor( m_colControlBright ); + + m_Render->DrawFilledRect( rect ); + + // Border + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 85, 130, 164, 255 ) ); + else m_Render->SetDrawColor( m_colControlOutlineLight ); + + m_Render->DrawLinedRect( rect ); + + m_Render->SetDrawColor( Gwen::Color( 0, 50, 60, 15 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w-4, rect.h-4 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w*0.3f, rect.h-4 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w-4, rect.h*0.3f ) ); + + if ( control->IsHovered() ) m_Render->SetDrawColor( Gwen::Color( 121, 198, 249, 255 ) ); + else m_Render->SetDrawColor( Gwen::Color( 0, 50, 60, 50 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, 1, rect.h-4 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+2, rect.y+2, rect.w-4, 1 ) ); + + + + if ( bDepressed ) + { + m_Render->SetDrawColor( Color( 100, 100, 100, 255) ); + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + DrawCheck( r ); + } + else if ( bSelected ) + { + m_Render->SetDrawColor( Color( 0, 0, 0, 255) ); + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + DrawCheck( r ); + } + } + + virtual void DrawGroupBox( Gwen::Controls::Base* control, int textStart, int textHeight, int textWidth ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + rect.y += textHeight * 0.5f; + rect.h -= textHeight * 0.5f; + + Gwen::Color m_colDarker = Gwen::Color( 0, 50, 60, 50 ); + Gwen::Color m_colLighter = Gwen::Color( 255, 255, 255, 150 ); + + m_Render->SetDrawColor( m_colLighter ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y+1, textStart-3, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1+textStart+textWidth, rect.y+1, rect.w-textStart+textWidth-2, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, (rect.y + rect.h)-1, rect.w-2, 1 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y+1, 1, rect.h ) ); + m_Render->DrawFilledRect( Gwen::Rect( (rect.x + rect.w)-2, rect.y+1, 1, rect.h-1 ) ); + + m_Render->SetDrawColor( m_colDarker ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y, textStart-3, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1+textStart+textWidth, rect.y, rect.w-textStart-textWidth-2, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, (rect.y + rect.h) -1, rect.w-2, 1 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x, rect.y+1, 1, rect.h-1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( (rect.x + rect.w)-1, rect.y+1, 1, rect.h-1 ) ); + } + + virtual void DrawTextBox( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + bool bHasFocus = control->HasFocus(); + + // Box inside + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 255 ) ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-2 ) ); + + m_Render->SetDrawColor( m_colControlOutlineLight ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y, rect.w-2, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x, rect.y+1, 1, rect.h-2 ) ); + + m_Render->SetDrawColor( m_colControlOutlineLighter ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, (rect.y + rect.h)-1, rect.w-2, 1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( (rect.x + rect.w)-1, rect.y+1, 1, rect.h-2 ) ); + + if ( bHasFocus ) + { + m_Render->SetDrawColor( Gwen::Color( 50, 200, 255, 150 ) ); + m_Render->DrawLinedRect( rect ); + } + } + + virtual void DrawTabButton( Gwen::Controls::Base* control, bool bActive, int dir ) + { + Gwen::Rect rect = control->GetRenderBounds(); + bool bHovered = control->IsHovered(); + + if ( bHovered )m_Render->SetDrawColor( m_colControlBright ); + else m_Render->SetDrawColor( m_colControl ); + + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-1 ) ); + + if ( bHovered )m_Render->SetDrawColor( m_colControl ); + else m_Render->SetDrawColor( m_colControlDark ); + + m_Render->DrawFilledRect( Gwen::Rect( 1, rect.h*0.5, rect.w-2, rect.h*0.5-1 ) ); + + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 1, 1, rect.w-2, rect.h ) ); + + m_Render->SetDrawColor( m_colBorderColor ); + + m_Render->DrawShavedCornerRect( Gwen::Rect( 0, 0, rect.w, rect.h ) ); + } + + virtual void DrawTabControl( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + m_Render->SetDrawColor( m_colControl ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawLinedRect( rect ); + + //m_Render->SetDrawColor( m_colControl ); + //m_Render->DrawFilledRect( CurrentButtonRect ); + } + + virtual void DrawWindow( Gwen::Controls::Base* control, int topHeight, bool inFocus ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + // Titlebar + if ( inFocus ) + m_Render->SetDrawColor( Gwen::Color( 87, 164, 232, 230 ) ); + else + m_Render->SetDrawColor( Gwen::Color( 87*0.70, 164*0.70, 232*0.70, 230 ) ); + + int iBorderSize = 5; + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y+1, rect.w-2, topHeight-1 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y+topHeight-1, iBorderSize, rect.h-2-topHeight ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+rect.w-iBorderSize, rect.y+topHeight-1, iBorderSize, rect.h-2-topHeight ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+1, rect.y+rect.h-iBorderSize, rect.w-2, iBorderSize ) ); + + // Main inner + m_Render->SetDrawColor( Gwen::Color( m_colControlDark.r, m_colControlDark.g, m_colControlDark.b, 230 ) ); + m_Render->DrawFilledRect( Gwen::Rect( rect.x+iBorderSize+1, rect.y+topHeight, rect.w-iBorderSize*2-2, rect.h-topHeight-iBorderSize-1 ) ); + + // Light inner border + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 100 ) ); + m_Render->DrawShavedCornerRect( Gwen::Rect( rect.x+1, rect.y+1, rect.w-2, rect.h-2 ) ); + + // Dark line between titlebar and main + m_Render->SetDrawColor( m_colBorderColor ); + + // Inside border + m_Render->SetDrawColor( m_colControlOutlineNormal ); + m_Render->DrawLinedRect( Gwen::Rect( rect.x+iBorderSize, rect.y+topHeight-1, rect.w - 10, rect.h - topHeight - (iBorderSize - 1) ) ); + + // Dark outer border + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawShavedCornerRect( Gwen::Rect( rect.x, rect.y, rect.w, rect.h ) ); + } + + virtual void DrawHighlight( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + m_Render->SetDrawColor( Gwen::Color( 255, 100, 255, 255 ) ); + m_Render->DrawFilledRect( rect ); + } + + virtual void DrawScrollBar( Gwen::Controls::Base* control, bool isHorizontal, bool bDepressed ) + { + Gwen::Rect rect = control->GetRenderBounds(); + if (bDepressed) + m_Render->SetDrawColor( m_colControlDarker ); + else + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawFilledRect( rect ); + } + + virtual void DrawScrollBarBar( Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal ) + { + //TODO: something specialized + DrawButton( control, bDepressed, isHovered, false ); + } + + virtual void DrawTabTitleBar( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + m_Render->SetDrawColor( Gwen::Color( 177, 193, 214, 255 ) ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + rect.h += 1; + m_Render->DrawLinedRect( rect ); + } + + virtual void DrawProgressBar( Gwen::Controls::Base* control, bool isHorizontal, float progress) + { + Gwen::Rect rect = control->GetRenderBounds(); + Gwen::Color FillColour( 0, 211, 40, 255 ); + + if ( isHorizontal ) + { + //Background + m_Render->SetDrawColor( m_colControlDark ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-2 ) ); + + //Right half + m_Render->SetDrawColor( FillColour ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w*progress-2, rect.h-2 ) ); + + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 150 ) ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h*0.45f ) ); + } + else + { + //Background + m_Render->SetDrawColor( m_colControlDark ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-2 ) ); + + //Top half + m_Render->SetDrawColor( FillColour ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1 + (rect.h * (1 - progress)), rect.w-2, rect.h * progress - 2 ) ); + + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 150 ) ); + m_Render->DrawFilledRect( Gwen::Rect( 1, 1, rect.w*0.45f, rect.h-2 ) ); + } + + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 150 ) ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 1, 1, rect.w-2, rect.h-2 ) ); + + m_Render->SetDrawColor( Gwen::Color( 255, 255, 255, 70 ) ); + m_Render->DrawShavedCornerRect( Gwen::Rect( 2, 2, rect.w-4, rect.h-4 ) ); + + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawShavedCornerRect( rect ); + } + + virtual void DrawListBox( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawLinedRect( rect ); + } + + virtual void DrawListBoxLine( Gwen::Controls::Base* control, bool bSelected, bool bEven ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + if ( bSelected ) + { + m_Render->SetDrawColor( m_colHighlightBorder ); + m_Render->DrawFilledRect( rect ); + } + else if ( control->IsHovered() ) + { + m_Render->SetDrawColor( m_colHighlightBG ); + m_Render->DrawFilledRect( rect ); + } + } + + + virtual void DrawSlider( Gwen::Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize) + { + Gwen::Rect rect = control->GetRenderBounds(); + Gwen::Rect notchRect = rect; + + if ( bIsHorizontal ) + { + rect.y += rect.h * 0.4; + rect.h -= rect.h * 0.8; + } + else + { + rect.x += rect.w * 0.4; + rect.w -= rect.w * 0.8; + } + + m_Render->SetDrawColor( m_colBGDark ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colControlDarker ); + m_Render->DrawLinedRect( rect ); + } + + virtual void DrawComboBox( Gwen::Controls::Base* control, bool bIsDown, bool bIsMenuOpen ) + { + DrawTextBox( control ); + } + + virtual void DrawKeyboardHighlight( Gwen::Controls::Base* control, const Gwen::Rect& r, int iOffset ) + { + Gwen::Rect rect = r; + + rect.x += iOffset; + rect.y += iOffset; + rect.w -= iOffset*2; + rect.h -= iOffset*2; + + //draw the top and bottom + bool skip = true; + for(int i=0; i< rect.w*0.5; i++) + { + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + if (!skip) + { + m_Render->DrawPixel(rect.x + (i*2), rect.y); + m_Render->DrawPixel(rect.x + (i*2), rect.y+rect.h-1); + } + else + skip = !skip; + } + skip = false; + for(int i=0; i< rect.h*0.5; i++) + { + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + if (!skip) + { + m_Render->DrawPixel(rect.x , rect.y +i*2); + m_Render->DrawPixel(rect.x +rect.w-1, rect.y +i*2 ); + } + else + skip = !skip; + } + } + + virtual void DrawToolTip( Gwen::Controls::Base* control ) + { + Gwen::Rect rct = control->GetRenderBounds(); + rct.x -= 3; + rct.y -= 3; + rct.w += 6; + rct.h += 6; + + m_Render->SetDrawColor( m_colToolTipBackground ); + m_Render->DrawFilledRect( rct ); + + m_Render->SetDrawColor( m_colToolTipBorder ); + m_Render->DrawLinedRect( rct ); + } + + virtual void DrawScrollButton( Gwen::Controls::Base* control, int iDirection, bool bDepressed, bool bHovered, bool bDisabled ) + { + DrawButton( control, bDepressed, false, false ); + + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 240 ) ); + + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + + if ( iDirection == Gwen::Pos::Top ) DrawArrowUp( r ); + else if ( iDirection == Gwen::Pos::Bottom ) DrawArrowDown( r ); + else if ( iDirection == Gwen::Pos::Left ) DrawArrowLeft( r ); + else DrawArrowRight( r ); + } + + virtual void DrawComboDownArrow( Gwen::Controls::Base* control, bool bHovered, bool bDown, bool bOpen, bool bDisabled ) + { + //DrawButton( control->Width(), control->Height(), bDepressed, false, true ); + + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 240 ) ); + + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + DrawArrowDown( r ); + } + + virtual void DrawNumericUpDownButton( Gwen::Controls::Base* control, bool bDepressed, bool bUp ) + { + //DrawButton( control->Width(), control->Height(), bDepressed, false, true ); + + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 240 ) ); + + Gwen::Rect r( control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5 ); + + if ( bUp ) DrawArrowUp( r ); + else DrawArrowDown( r ); + + } + + virtual void DrawTreeButton( Controls::Base* control, bool bOpen ) + { + Gwen::Rect rect = control->GetRenderBounds(); + rect.x += 2; + rect.y += 2; + rect.w -= 4; + rect.h -= 4; + + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawLinedRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + + if ( !bOpen ) // ! because the button shows intention, not the current state + m_Render->DrawFilledRect( Gwen::Rect( rect.x + rect.w/2, rect.y + 2, 1, rect.h - 4 ) ); + + m_Render->DrawFilledRect( Gwen::Rect( rect.x +2, rect.y + rect.h/2, rect.w-4, 1 ) ); + + } + + virtual void DrawTreeControl( Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + m_Render->SetDrawColor( m_colControlBright ); + m_Render->DrawFilledRect( rect ); + + m_Render->SetDrawColor( m_colBorderColor ); + m_Render->DrawLinedRect( rect ); + } + + void DrawTreeNode( Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot ) + { + if ( bSelected ) + { + GetRender()->SetDrawColor( Color( 0, 150, 255, 100 ) ); + GetRender()->DrawFilledRect( Gwen::Rect( 17, 0, iLabelWidth + 2, iLabelHeight-1 ) ); + GetRender()->SetDrawColor( Color( 0, 150, 255, 200 ) ); + GetRender()->DrawLinedRect( Gwen::Rect( 17, 0, iLabelWidth + 2, iLabelHeight-1 ) ); + } + + Base::DrawTreeNode( ctrl, bOpen, bSelected, iLabelHeight, iLabelWidth, iHalfWay, iLastBranch, bIsRoot ); + } + + virtual void DrawStatusBar( Controls::Base* control ) + { + // TODO. + } + + void DrawColorDisplay( Controls::Base* control, Gwen::Color color ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + if ( color.a != 255 ) + { + GetRender()->SetDrawColor( Gwen::Color( 255, 255, 255, 255 ) ); + GetRender()->DrawFilledRect( rect ); + + GetRender()->SetDrawColor( Gwen::Color( 128, 128, 128, 128 ) ); + + GetRender()->DrawFilledRect( Gwen::Rect( 0, 0, rect.w * 0.5, rect.h * 0.5) ); + GetRender()->DrawFilledRect( Gwen::Rect( rect.w * 0.5, rect.h * 0.5, rect.w * 0.5,rect.h * 0.5) ); + } + + GetRender()->SetDrawColor( color ); + GetRender()->DrawFilledRect( rect ); + + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + GetRender()->DrawLinedRect( rect ); + } + + virtual void DrawModalControl( Controls::Base* control ) + { + if ( control->ShouldDrawBackground() ) + { + Gwen::Rect rect = control->GetRenderBounds(); + GetRender()->SetDrawColor( m_colModal ); + GetRender()->DrawFilledRect( rect ); + } + } + + virtual void DrawMenuDivider( Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + GetRender()->SetDrawColor( m_colBGDark ); + GetRender()->DrawFilledRect( rect ); + GetRender()->SetDrawColor( m_colControlDarker); + GetRender()->DrawLinedRect( rect ); + } + + virtual void DrawMenuRightArrow( Controls::Base* control ) + { + DrawArrowRight( control->GetRenderBounds() ); + } + + virtual void DrawSlideButton( Gwen::Controls::Base* control, bool bDepressed, bool bHorizontal ) + { + DrawButton( control, bDepressed, control->IsHovered(), control->IsDisabled() ); + } + + virtual void DrawCategoryHolder( Controls::Base* ctrl ){} + virtual void DrawCategoryInner( Controls::Base* ctrl, bool bCollapsed ){} + }; + } +} +#endif diff --git a/lib/gwen/skins/gwen_texturedbase.h b/lib/gwen/skins/gwen_texturedbase.h new file mode 100644 index 0000000..29f16e1 --- /dev/null +++ b/lib/gwen/skins/gwen_texturedbase.h @@ -0,0 +1,1056 @@ +#pragma once +#ifndef GWEN_SKINS_TEXTUREDBASE_H +#define GWEN_SKINS_TEXTUREDBASE_H + +#include "../gwen_skin.h" +#include "../gwen.h" +#include "../controls/gwen_base.h" +#include "../gwen_texture.h" +#include "gwen_texturing.h" + +namespace Gwen +{ + namespace Skin + { + class TexturedBase : public Gwen::Skin::Base + { + public: + + TexturedBase( Gwen::Renderer::Base* renderer ) : Gwen::Skin::Base( renderer ) + { + + } + + ~TexturedBase() + { + m_Texture.Release( m_Render ); + } + + Texture m_Texture; + + struct Textures_t + { + Texturing::Bordered StatusBar; + Texturing::Bordered Selection; + Texturing::Bordered Shadow; + Texturing::Bordered Tooltip; + + struct Panel_t + { + Texturing::Bordered Normal; + Texturing::Bordered Bright; + Texturing::Bordered Dark; + Texturing::Bordered Highlight; + + } Panel; + + struct Window_t + { + Texturing::Bordered Normal; + Texturing::Bordered Inactive; + Texturing::Single Close; + Texturing::Single Close_Hover; + Texturing::Single Close_Down; + Texturing::Single Maxi; + Texturing::Single Maxi_Hover; + Texturing::Single Maxi_Down; + Texturing::Single Mini; + Texturing::Single Mini_Hover; + Texturing::Single Mini_Down; + Texturing::Single Restore; + Texturing::Single Restore_Hover; + Texturing::Single Restore_Down; + + } Window; + + + + struct Checkbox_t + { + struct Active_t + { + Texturing::Single Normal; + Texturing::Single Checked; + + } Active; + + struct Disabled_t + { + Texturing::Single Normal; + Texturing::Single Checked; + + } Disabled; + + } Checkbox; + + struct RadioButton_t + { + struct Active_t + { + Texturing::Single Normal; + Texturing::Single Checked; + + } Active; + + struct Disabled_t + { + Texturing::Single Normal; + Texturing::Single Checked; + + } Disabled; + + } RadioButton; + + struct TextBox_t + { + Texturing::Bordered Normal; + Texturing::Bordered Focus; + Texturing::Bordered Disabled; + + } TextBox; + + struct Tree_t + { + Texturing::Bordered Background; + Texturing::Single Minus; + Texturing::Single Plus; + + } Tree; + + + struct ProgressBar_t + { + Texturing::Bordered Back; + Texturing::Bordered Front; + + } ProgressBar; + + struct Scroller_t + { + Texturing::Bordered TrackV; + Texturing::Bordered ButtonV_Normal; + Texturing::Bordered ButtonV_Hover; + Texturing::Bordered ButtonV_Down; + Texturing::Bordered ButtonV_Disabled; + Texturing::Bordered TrackH; + Texturing::Bordered ButtonH_Normal; + Texturing::Bordered ButtonH_Hover; + Texturing::Bordered ButtonH_Down; + Texturing::Bordered ButtonH_Disabled; + + struct Button_t + { + Texturing::Bordered Normal[4]; + Texturing::Bordered Hover[4]; + Texturing::Bordered Down[4]; + Texturing::Bordered Disabled[4]; + + } Button; + + } Scroller; + + struct Menu_t + { + Texturing::Single RightArrow; + Texturing::Single Check; + + Texturing::Bordered Strip; + Texturing::Bordered Background; + Texturing::Bordered BackgroundWithMargin; + Texturing::Bordered Hover; + + } Menu; + + struct Input_t + { + struct Button_t + { + Texturing::Bordered Normal; + Texturing::Bordered Hovered; + Texturing::Bordered Disabled; + Texturing::Bordered Pressed; + + } Button; + + struct ListBox_t + { + Texturing::Bordered Background; + Texturing::Bordered Hovered; + + Texturing::Bordered EvenLine; + Texturing::Bordered OddLine; + Texturing::Bordered EvenLineSelected; + Texturing::Bordered OddLineSelected; + + } ListBox; + + struct UpDown_t + { + struct Up_t + { + Texturing::Single Normal; + Texturing::Single Hover; + Texturing::Single Down; + Texturing::Single Disabled; + + } Up; + + struct Down_t + { + Texturing::Single Normal; + Texturing::Single Hover; + Texturing::Single Down; + Texturing::Single Disabled; + + } Down; + + } UpDown; + + struct ComboBox_t + { + Texturing::Bordered Normal; + Texturing::Bordered Hover; + Texturing::Bordered Down; + Texturing::Bordered Disabled; + + struct Button_t + { + Texturing::Single Normal; + Texturing::Single Hover; + Texturing::Single Down; + Texturing::Single Disabled; + + } Button; + + } ComboBox; + + struct Slider_t + { + struct H_t + { + Texturing::Single Normal; + Texturing::Single Hover; + Texturing::Single Down; + Texturing::Single Disabled; + } H; + + struct V_t + { + Texturing::Single Normal; + Texturing::Single Hover; + Texturing::Single Down; + Texturing::Single Disabled; + } V; + + } Slider; + + } Input; + + struct Tab_t + { + struct Bottom_t + { + Texturing::Bordered Active; + Texturing::Bordered Inactive; + } Bottom; + + struct Top_t + { + Texturing::Bordered Active; + Texturing::Bordered Inactive; + } Top; + + struct Left_t + { + Texturing::Bordered Active; + Texturing::Bordered Inactive; + } Left; + + struct Right_t + { + Texturing::Bordered Active; + Texturing::Bordered Inactive; + } Right; + + Texturing::Bordered Control; + Texturing::Bordered HeaderBar; + + } Tab; + + struct CategoryList_t + { + Texturing::Bordered Outer; + Texturing::Bordered Inner; + Texturing::Bordered Header; + + } CategoryList; + + Texturing::Bordered GroupBox; + + } Textures; + + + virtual void Init( const TextObject& TextureName ) + { + m_DefaultFont.facename = "Microsoft Sans Serif"; + m_DefaultFont.size = 11; + + m_Texture.Load( TextureName, GetRender() ); + + + Colors.Window.TitleActive = GetRender()->PixelColour( &m_Texture, 4 + 8 * 0, 508, Color( 255, 0, 0 ) ); + Colors.Window.TitleInactive = GetRender()->PixelColour( &m_Texture, 4 + 8 * 1, 508, Color( 255, 255, 0) ); + Colors.Button.Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 2, 508, Color( 255, 255, 0) ); + Colors.Button.Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 3, 508, Color( 255, 255, 0) ); + Colors.Button.Down = GetRender()->PixelColour( &m_Texture, 4 + 8 * 2, 500, Color( 255, 255, 0) ); + Colors.Button.Disabled = GetRender()->PixelColour( &m_Texture, 4 + 8 * 3, 500, Color( 255, 255, 0) ); + Colors.Tab.Active.Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 4, 508, Color( 255, 255, 0) ); + Colors.Tab.Active.Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 5, 508, Color( 255, 255, 0) ); + Colors.Tab.Active.Down = GetRender()->PixelColour( &m_Texture, 4 + 8 * 4, 500, Color( 255, 255, 0) ); + Colors.Tab.Active.Disabled = GetRender()->PixelColour( &m_Texture, 4 + 8 * 5, 500, Color( 255, 255, 0) ); + Colors.Tab.Inactive.Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 6, 508, Color( 255, 255, 0) ); + Colors.Tab.Inactive.Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 7, 508, Color( 255, 255, 0) ); + Colors.Tab.Inactive.Down = GetRender()->PixelColour( &m_Texture, 4 + 8 * 6, 500, Color( 255, 255, 0) ); + Colors.Tab.Inactive.Disabled = GetRender()->PixelColour( &m_Texture, 4 + 8 * 7, 500, Color( 255, 255, 0) ); + Colors.Label.Default = GetRender()->PixelColour( &m_Texture, 4 + 8 * 8, 508, Color( 255, 255, 0) ); + Colors.Label.Bright = GetRender()->PixelColour( &m_Texture, 4 + 8 * 9, 508, Color( 255, 255, 0) ); + Colors.Label.Dark = GetRender()->PixelColour( &m_Texture, 4 + 8 * 8, 500, Color( 255, 255, 0) ); + Colors.Label.Highlight = GetRender()->PixelColour( &m_Texture, 4 + 8 * 9, 500, Color( 255, 255, 0) ); + + Colors.Tree.Lines = GetRender()->PixelColour( &m_Texture, 4 + 8 * 10, 508, Color( 255, 255, 0) ); + Colors.Tree.Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 11, 508, Color( 255, 255, 0) ); + Colors.Tree.Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 10, 500, Color( 255, 255, 0) ); + Colors.Tree.Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 11, 500, Color( 255, 255, 0) ); + + Colors.Properties.Line_Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 12, 508, Color( 255, 255, 0) ); + Colors.Properties.Line_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 13, 508, Color( 255, 255, 0) ); + Colors.Properties.Line_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 12, 500, Color( 255, 255, 0) ); + Colors.Properties.Title = GetRender()->PixelColour( &m_Texture, 4 + 8 * 13, 500, Color( 255, 255, 0) ); + + Colors.Properties.Column_Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 14, 508, Color( 255, 255, 0) ); + Colors.Properties.Column_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 15, 508, Color( 255, 255, 0) ); + Colors.Properties.Column_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 14, 500, Color( 255, 255, 0) ); + Colors.Properties.Border = GetRender()->PixelColour( &m_Texture, 4 + 8 * 15, 500, Color( 255, 255, 0) ); + + Colors.Properties.Label_Normal = GetRender()->PixelColour( &m_Texture, 4 + 8 * 16, 508, Color( 255, 255, 0) ); + Colors.Properties.Label_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 17, 508, Color( 255, 255, 0) ); + Colors.Properties.Label_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 16, 500, Color( 255, 255, 0) ); + + Colors.ModalBackground = GetRender()->PixelColour( &m_Texture, 4 + 8 * 18, 508, Color( 255, 255, 0) ); + Colors.TooltipText = GetRender()->PixelColour( &m_Texture, 4 + 8 * 19, 508, Color( 255, 255, 0) ); + Colors.Category.Header = GetRender()->PixelColour( &m_Texture, 4 + 8 * 18, 500, Color( 255, 255, 0) ); + Colors.Category.Header_Closed = GetRender()->PixelColour( &m_Texture, 4 + 8 * 19, 500, Color( 255, 255, 0) ); + + Colors.Category.Line.Text = GetRender()->PixelColour( &m_Texture, 4 + 8 * 20, 508, Color( 255, 255, 0) ); + Colors.Category.Line.Text_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 21, 508, Color( 255, 255, 0) ); + Colors.Category.Line.Text_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 20, 500, Color( 255, 255, 0) ); + Colors.Category.Line.Button = GetRender()->PixelColour( &m_Texture, 4 + 8 * 21, 500, Color( 255, 255, 0) ); + + Colors.Category.Line.Button_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 22, 508, Color( 255, 255, 0) ); + Colors.Category.Line.Button_Selected= GetRender()->PixelColour( &m_Texture, 4 + 8 * 23, 508, Color( 255, 255, 0) ); + Colors.Category.LineAlt.Text = GetRender()->PixelColour( &m_Texture, 4 + 8 * 22, 500, Color( 255, 255, 0) ); + Colors.Category.LineAlt.Text_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 23, 500, Color( 255, 255, 0) ); + + Colors.Category.LineAlt.Text_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 24, 508, Color( 255, 255, 0) ); + Colors.Category.LineAlt.Button = GetRender()->PixelColour( &m_Texture, 4 + 8 * 25, 508, Color( 255, 255, 0) ); + Colors.Category.LineAlt.Button_Hover = GetRender()->PixelColour( &m_Texture, 4 + 8 * 24, 500, Color( 255, 255, 0) ); + Colors.Category.LineAlt.Button_Selected = GetRender()->PixelColour( &m_Texture, 4 + 8 * 25, 500, Color( 255, 255, 0) ); + + Textures.Shadow.Init ( &m_Texture, 448, 0, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Tooltip.Init ( &m_Texture, 128, 320, 127, 31, Margin( 8, 8, 8, 8 ) ); + Textures.StatusBar.Init ( &m_Texture, 128, 288, 127, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Selection.Init ( &m_Texture, 384, 32, 31, 31, Margin( 4, 4, 4, 4 ) ); + + Textures.Panel.Normal.Init ( &m_Texture, 256, 0, 63, 63, Margin( 16, 16, 16, 16 ) ); + Textures.Panel.Bright.Init ( &m_Texture, 256+64, 0, 63, 63, Margin( 16, 16, 16, 16 ) ); + Textures.Panel.Dark.Init ( &m_Texture, 256, 64, 63, 63, Margin( 16, 16, 16, 16 ) ); + Textures.Panel.Highlight.Init ( &m_Texture, 256+64, 64, 63, 63, Margin( 16, 16, 16, 16 ) ); + + Textures.Window.Normal.Init ( &m_Texture, 0, 0, 127, 127, Margin( 8, 32, 8, 8 ) ); + Textures.Window.Inactive.Init ( &m_Texture, 128, 0, 127, 127, Margin( 8, 32, 8, 8 ) ); + + Textures.Checkbox.Active.Checked.Init ( &m_Texture, 448, 32, 15, 15 ); + Textures.Checkbox.Active.Normal.Init ( &m_Texture, 464, 32, 15, 15 ); + Textures.Checkbox.Disabled.Checked.Init ( &m_Texture, 448, 48, 15, 15 ); + Textures.Checkbox.Disabled.Normal.Init ( &m_Texture, 464, 48, 15, 15 ); + + Textures.RadioButton.Active.Checked.Init ( &m_Texture, 448, 64, 15, 15 ); + Textures.RadioButton.Active.Normal.Init ( &m_Texture, 464, 64, 15, 15 ); + Textures.RadioButton.Disabled.Checked.Init ( &m_Texture, 448, 80, 15, 15 ); + Textures.RadioButton.Disabled.Normal.Init ( &m_Texture, 464, 80, 15, 15 ); + + Textures.TextBox.Normal.Init ( &m_Texture, 0, 150, 127, 21, Margin( 4, 4, 4, 4 ) ); + Textures.TextBox.Focus.Init ( &m_Texture, 0, 172, 127, 21, Margin( 4, 4, 4, 4 ) ); + Textures.TextBox.Disabled.Init ( &m_Texture, 0, 193, 127, 21, Margin( 4, 4, 4, 4 ) ); + + Textures.Menu.Strip.Init ( &m_Texture, 0, 128, 127, 21, Margin( 1, 1, 1, 1 ) ); + Textures.Menu.BackgroundWithMargin.Init ( &m_Texture, 128, 128, 127, 63, Margin( 24, 8, 8, 8 ) ); + Textures.Menu.Background.Init ( &m_Texture, 128, 192, 127, 63, Margin( 8, 8, 8, 8 ) ); + Textures.Menu.Hover.Init ( &m_Texture, 128, 256, 127, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Menu.RightArrow.Init ( &m_Texture, 464, 112, 15, 15 ); + Textures.Menu.Check.Init ( &m_Texture, 448, 112, 15, 15 ); + + Textures.Tab.Control.Init ( &m_Texture, 0, 256, 127, 127, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Bottom.Active.Init ( &m_Texture, 0, 416, 63, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Bottom.Inactive.Init ( &m_Texture, 0+128, 416, 63, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Top.Active.Init ( &m_Texture, 0, 384, 63, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Top.Inactive.Init ( &m_Texture, 0+128, 384, 63, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Left.Active.Init ( &m_Texture, 64, 384, 31, 63, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Left.Inactive.Init ( &m_Texture, 64+128, 384, 31, 63, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Right.Active.Init ( &m_Texture, 96, 384, 31, 63, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.Right.Inactive.Init ( &m_Texture, 96+128, 384, 31, 63, Margin( 8, 8, 8, 8 ) ); + Textures.Tab.HeaderBar.Init ( &m_Texture, 128, 352, 127, 31, Margin( 4, 4, 4, 4 ) ); + + Textures.Window.Close.Init ( &m_Texture, 32, 448, 31, 31 ); + Textures.Window.Close_Hover.Init ( &m_Texture, 64, 448, 31, 31 ); + Textures.Window.Close_Down.Init ( &m_Texture, 96, 448, 31, 31 ); + + Textures.Window.Maxi.Init ( &m_Texture, 32 + 96*2, 448, 31, 31 ); + Textures.Window.Maxi_Hover.Init ( &m_Texture, 64 + 96*2, 448, 31, 31 ); + Textures.Window.Maxi_Down.Init ( &m_Texture, 96 + 96*2, 448, 31, 31 ); + + Textures.Window.Restore.Init ( &m_Texture, 32 + 96*2, 448+32, 31, 31 ); + Textures.Window.Restore_Hover.Init ( &m_Texture, 64 + 96*2, 448+32, 31, 31 ); + Textures.Window.Restore_Down.Init ( &m_Texture, 96 + 96*2, 448+32, 31, 31 ); + + Textures.Window.Mini.Init ( &m_Texture, 32 + 96, 448, 31, 31 ); + Textures.Window.Mini_Hover.Init ( &m_Texture, 64 + 96, 448, 31, 31 ); + Textures.Window.Mini_Down.Init ( &m_Texture, 96 + 96, 448, 31, 31 ); + + Textures.Tree.Background.Init ( &m_Texture, 256, 128, 127, 127, Margin( 16, 16, 16, 16 ) ); + Textures.Tree.Plus.Init ( &m_Texture, 448, 96, 15, 15 ); + Textures.Tree.Minus.Init ( &m_Texture, 464, 96, 15, 15 ); + + Textures.Input.Button.Normal.Init ( &m_Texture, 480, 0, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.Button.Hovered.Init ( &m_Texture, 480, 32, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.Button.Disabled.Init ( &m_Texture, 480, 64, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.Button.Pressed.Init ( &m_Texture, 480, 96, 31, 31, Margin( 8, 8, 8, 8 ) ); + + for ( int i=0; i<4; i++ ) + { + Textures.Scroller.Button.Normal[i].Init ( &m_Texture, 464 + 0, 208 + i * 16, 15, 15, Margin( 2, 2, 2, 2 ) ); + Textures.Scroller.Button.Hover[i].Init ( &m_Texture, 480, 208 + i * 16, 15, 15, Margin( 2, 2, 2, 2 ) ); + Textures.Scroller.Button.Down[i].Init ( &m_Texture, 464, 272 + i * 16, 15, 15, Margin( 2, 2, 2, 2 ) ); + Textures.Scroller.Button.Disabled[i].Init ( &m_Texture, 480 + 48, 272 + i * 16, 15, 15, Margin( 2, 2, 2, 2 ) ); + } + + Textures.Scroller.TrackV.Init ( &m_Texture, 384, 208, 15, 127, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonV_Normal.Init ( &m_Texture, 384 + 16, 208, 15, 127, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonV_Hover.Init ( &m_Texture, 384 + 32, 208, 15, 127, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonV_Down.Init ( &m_Texture, 384 + 48, 208, 15, 127, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonV_Disabled.Init ( &m_Texture, 384 + 64, 208, 15, 127, Margin( 4, 4, 4, 4 ) ); + + Textures.Scroller.TrackH.Init ( &m_Texture, 384, 128, 127, 15, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonH_Normal.Init ( &m_Texture, 384, 128 + 16, 127, 15, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonH_Hover.Init ( &m_Texture, 384, 128 + 32, 127, 15, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonH_Down.Init ( &m_Texture, 384, 128 + 48, 127, 15, Margin( 4, 4, 4, 4 ) ); + Textures.Scroller.ButtonH_Disabled.Init ( &m_Texture, 384, 128 + 64, 127, 15, Margin( 4, 4, 4, 4 ) ); + + + + Textures.Input.ListBox.Background.Init ( &m_Texture, 256, 256, 63, 127, Margin( 8, 8, 8, 8 ) ); + Textures.Input.ListBox.Hovered.Init ( &m_Texture, 320, 320, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.ListBox.EvenLine.Init ( &m_Texture, 352, 256, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.ListBox.OddLine.Init ( &m_Texture, 352, 288, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.ListBox.EvenLineSelected.Init( &m_Texture, 320, 256, 31, 31, Margin( 8, 8, 8, 8 ) ); + Textures.Input.ListBox.OddLineSelected.Init ( &m_Texture, 320, 288, 31, 31, Margin( 8, 8, 8, 8 ) ); + + Textures.Input.ComboBox.Normal.Init ( &m_Texture, 384, 336, 127, 31, Margin( 8, 8, 32, 8 ) ); + Textures.Input.ComboBox.Hover.Init ( &m_Texture, 384, 336+32, 127, 31, Margin( 8, 8, 32, 8 ) ); + Textures.Input.ComboBox.Down.Init ( &m_Texture, 384, 336+64, 127, 31, Margin( 8, 8, 32, 8 ) ); + Textures.Input.ComboBox.Disabled.Init ( &m_Texture, 384, 336+96, 127, 31, Margin( 8, 8, 32, 8 ) ); + + Textures.Input.ComboBox.Button.Normal.Init ( &m_Texture, 496, 272, 15, 15 ); + Textures.Input.ComboBox.Button.Hover.Init ( &m_Texture, 496, 272+16, 15, 15 ); + Textures.Input.ComboBox.Button.Down.Init ( &m_Texture, 496, 272+32, 15, 15 ); + Textures.Input.ComboBox.Button.Disabled.Init ( &m_Texture, 496, 272+48, 15, 15 ); + + Textures.Input.UpDown.Up.Normal.Init ( &m_Texture, 384, 112, 7, 7 ); + Textures.Input.UpDown.Up.Hover.Init ( &m_Texture, 384+8, 112, 7, 7 ); + Textures.Input.UpDown.Up.Down.Init ( &m_Texture, 384+16, 112, 7, 7 ); + Textures.Input.UpDown.Up.Disabled.Init ( &m_Texture, 384+24, 112, 7, 7 ); + + Textures.Input.UpDown.Down.Normal.Init ( &m_Texture, 384, 120, 7, 7 ); + Textures.Input.UpDown.Down.Hover.Init ( &m_Texture, 384+8, 120, 7, 7 ); + Textures.Input.UpDown.Down.Down.Init ( &m_Texture, 384+16, 120, 7, 7 ); + Textures.Input.UpDown.Down.Disabled.Init ( &m_Texture, 384+24, 120, 7, 7 ); + + Textures.ProgressBar.Back.Init ( &m_Texture, 384, 0, 31, 31, Margin( 2, 2, 2, 2 ) ); + Textures.ProgressBar.Front.Init ( &m_Texture, 384+32, 0, 31, 31, Margin( 2, 2, 2, 2 ) ); + + Textures.Input.Slider.H.Normal.Init ( &m_Texture, 416, 32, 15, 15 ); + Textures.Input.Slider.H.Hover.Init ( &m_Texture, 416, 32+16, 15, 15 ); + Textures.Input.Slider.H.Down.Init ( &m_Texture, 416, 32+32, 15, 15 ); + Textures.Input.Slider.H.Disabled.Init ( &m_Texture, 416, 32+48, 15, 15 ); + + Textures.Input.Slider.V.Normal.Init ( &m_Texture, 416+16, 32, 15, 15 ); + Textures.Input.Slider.V.Hover.Init ( &m_Texture, 416+16, 32+16, 15, 15 ); + Textures.Input.Slider.V.Down.Init ( &m_Texture, 416+16, 32+32, 15, 15 ); + Textures.Input.Slider.V.Disabled.Init ( &m_Texture, 416+16, 32+48, 15, 15 ); + + Textures.CategoryList.Outer.Init ( &m_Texture, 256, 384, 63, 63, Margin( 8, 8, 8, 8 ) ); + Textures.CategoryList.Inner.Init ( &m_Texture, 256 + 64, 384, 63, 63, Margin( 8, 21, 8, 8 ) ); + Textures.CategoryList.Header.Init ( &m_Texture, 320, 352, 63, 31, Margin( 8, 8, 8, 8 ) ); + + Textures.GroupBox.Init ( &m_Texture, 0, 448, 31, 31, Margin( 8, 8, 8, 8 ) ); + } + + + virtual void DrawButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + if ( bDisabled ) return Textures.Input.Button.Disabled.Draw( GetRender(), control->GetRenderBounds() ); + if ( bDepressed ) return Textures.Input.Button.Pressed.Draw( GetRender(), control->GetRenderBounds() ); + if ( bHovered ) return Textures.Input.Button.Hovered.Draw( GetRender(), control->GetRenderBounds() ); + + Textures.Input.Button.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawMenuItem( Gwen::Controls::Base* control, bool bSubmenuOpen, bool bChecked ) + { + const Gwen::Rect& rect = control->GetRenderBounds(); + + if ( bSubmenuOpen || control->IsHovered() ) Textures.Menu.Hover.Draw( GetRender(), rect ); + if ( bChecked ) Textures.Menu.Check.Draw( GetRender(), Gwen::Rect( rect.x+4, rect.y+3, 15, 15 )); + } + + virtual void DrawMenuStrip( Gwen::Controls::Base* control ) + { + Textures.Menu.Strip.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawMenu( Gwen::Controls::Base* control, bool bPaddingDisabled ) + { + if ( !bPaddingDisabled ) + { + return Textures.Menu.BackgroundWithMargin.Draw( GetRender(), control->GetRenderBounds() ); + } + + Textures.Menu.Background.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawMenuRightArrow( Controls::Base* control ) + { + Textures.Menu.RightArrow.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawShadow( Gwen::Controls::Base* control ) + { + Gwen::Rect r = control->GetRenderBounds(); + r.x -= 4; + r.y -= 4; + r.w += 10; + r.h += 10; + + Textures.Shadow.Draw( GetRender(), r ); + } + + virtual void DrawRadioButton( Gwen::Controls::Base* control, bool bSelected, bool bDepressed) + { + if ( bSelected ) + { + if ( control->IsDisabled() ) + Textures.RadioButton.Disabled.Checked.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.RadioButton.Active.Checked.Draw( GetRender(), control->GetRenderBounds() ); + } + else + { + if ( control->IsDisabled() ) + Textures.RadioButton.Disabled.Normal.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.RadioButton.Active.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + } + + + virtual void DrawCheckBox( Gwen::Controls::Base* control, bool bSelected, bool bDepressed) + { + if ( bSelected ) + { + if ( control->IsDisabled() ) + Textures.Checkbox.Disabled.Checked.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.Checkbox.Active.Checked.Draw( GetRender(), control->GetRenderBounds() ); + } + else + { + if ( control->IsDisabled() ) + Textures.Checkbox.Disabled.Normal.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.Checkbox.Active.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + } + + virtual void DrawGroupBox( Gwen::Controls::Base* control, int textStart, int textHeight, int textWidth ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + rect.y += textHeight * 0.5f; + rect.h -= textHeight * 0.5f; + + Textures.GroupBox.Draw( GetRender(), rect, Gwen::Colors::White, true, false ); + + rect.x += textStart + textWidth - 4; + rect.w -= textStart + textWidth - 4; + + Textures.GroupBox.Draw( GetRender(), rect, Gwen::Colors::White, false, true, false, false, false, false, false, false, false ); + } + + virtual void DrawTextBox( Gwen::Controls::Base* control ) + { + if ( control->IsDisabled() ) + return Textures.TextBox.Disabled.Draw( GetRender(), control->GetRenderBounds() ); + + if ( control->HasFocus() ) + Textures.TextBox.Focus.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.TextBox.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawActiveTabButton( Gwen::Controls::Base* control, int dir ) + { + if ( dir == Pos::Bottom ) return Textures.Tab.Bottom.Active.Draw( GetRender(), control->GetRenderBounds() + Rect( 0, -8, 0, 8 ) ); + if ( dir == Pos::Top ) return Textures.Tab.Top.Active.Draw( GetRender(), control->GetRenderBounds() + Rect( 0, 0, 0, 8 ) ); + if ( dir == Pos::Left ) return Textures.Tab.Left.Active.Draw( GetRender(), control->GetRenderBounds() + Rect( 0, 0, 8, 0 ) ); + if ( dir == Pos::Right ) return Textures.Tab.Right.Active.Draw( GetRender(), control->GetRenderBounds() + Rect( -8, 0, 8, 0 ) ); + } + + virtual void DrawTabButton( Gwen::Controls::Base* control, bool bActive, int dir ) + { + if ( bActive ) + return DrawActiveTabButton( control, dir ); + + if ( dir == Pos::Bottom ) return Textures.Tab.Bottom.Inactive.Draw( GetRender(), control->GetRenderBounds() ); + if ( dir == Pos::Top ) return Textures.Tab.Top.Inactive.Draw( GetRender(), control->GetRenderBounds() ); + if ( dir == Pos::Left ) return Textures.Tab.Left.Inactive.Draw( GetRender(), control->GetRenderBounds() ); + if ( dir == Pos::Right ) return Textures.Tab.Right.Inactive.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawTabControl( Gwen::Controls::Base* control ) + { + Textures.Tab.Control.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawTabTitleBar( Gwen::Controls::Base* control ) + { + Textures.Tab.HeaderBar.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawGenericPanel( Controls::Base* control ) + { + Textures.Panel.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawPanel( Controls::Base* control, unsigned char iPanelType = Gwen::Skin::Panel::Normal ) + { + switch (iPanelType) + { + case Gwen::Skin::Panel::Normal: + Textures.Panel.Normal.Draw( GetRender(), control->GetRenderBounds() ); + break; + case Gwen::Skin::Panel::Bright: + Textures.Panel.Bright.Draw( GetRender(), control->GetRenderBounds() ); + break; + case Gwen::Skin::Panel::Dark: + Textures.Panel.Dark.Draw( GetRender(), control->GetRenderBounds() ); + break; + case Gwen::Skin::Panel::Highlight: + Textures.Panel.Highlight.Draw( GetRender(), control->GetRenderBounds() ); + break; + } + } + + virtual void DrawWindow( Gwen::Controls::Base* control, int topHeight, bool inFocus ) + { + if ( inFocus ) Textures.Window.Normal.Draw( GetRender(), control->GetRenderBounds() ); + else Textures.Window.Inactive.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawHighlight( Gwen::Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + GetRender()->SetDrawColor( Gwen::Color( 255, 100, 255, 255 ) ); + GetRender()->DrawFilledRect( rect ); + } + + virtual void DrawScrollBar( Gwen::Controls::Base* control, bool isHorizontal, bool bDepressed ) + { + if ( isHorizontal ) + Textures.Scroller.TrackH.Draw( GetRender(), control->GetRenderBounds() ); + else + Textures.Scroller.TrackV.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawScrollBarBar( Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal ) + { + if ( !isHorizontal ) + { + if ( control->IsDisabled() ) + return Textures.Scroller.ButtonV_Disabled.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bDepressed ) + return Textures.Scroller.ButtonV_Down.Draw( GetRender(), control->GetRenderBounds() ); + + if ( isHovered ) + return Textures.Scroller.ButtonV_Hover.Draw( GetRender(), control->GetRenderBounds() ); + + return Textures.Scroller.ButtonV_Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + if ( control->IsDisabled() ) + return Textures.Scroller.ButtonH_Disabled.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bDepressed ) + return Textures.Scroller.ButtonH_Down.Draw( GetRender(), control->GetRenderBounds() ); + + if ( isHovered ) + return Textures.Scroller.ButtonH_Hover.Draw( GetRender(), control->GetRenderBounds() ); + + return Textures.Scroller.ButtonH_Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + + virtual void DrawProgressBar( Gwen::Controls::Base* control, bool isHorizontal, float progress) + { + Gwen::Rect rect = control->GetRenderBounds(); + Gwen::Color FillColour( 0, 211, 40, 255 ); + + if ( isHorizontal ) + { + Textures.ProgressBar.Back.Draw( GetRender(), rect ); + rect.w *= progress; + + if ( rect.w > 0 ) + Textures.ProgressBar.Front.Draw( GetRender(), rect ); + } + else + { + Textures.ProgressBar.Back.Draw( GetRender(), rect ); + + int inv_progress = rect.h * (1-progress); + rect.y += inv_progress; + rect.h -= inv_progress; + Textures.ProgressBar.Front.Draw( GetRender(), rect ); + } + } + + virtual void DrawListBox( Gwen::Controls::Base* control ) + { + return Textures.Input.ListBox.Background.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawListBoxLine( Gwen::Controls::Base* control, bool bSelected, bool bEven ) + { + if ( bSelected ) + { + if ( bEven ) + return Textures.Input.ListBox.EvenLineSelected.Draw( GetRender(), control->GetRenderBounds() ); + else + return Textures.Input.ListBox.OddLineSelected.Draw( GetRender(), control->GetRenderBounds() ); + } + + if ( control->IsHovered() ) + return Textures.Input.ListBox.Hovered.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bEven ) + return Textures.Input.ListBox.EvenLine.Draw( GetRender(), control->GetRenderBounds() ); + + return Textures.Input.ListBox.OddLine.Draw( GetRender(), control->GetRenderBounds() ); + } + + void DrawSliderNotchesH( Gwen::Rect rect, int numNotches, int dist ) + { + if ( numNotches == 0 ) return; + + float iSpacing = (float)rect.w / (float)numNotches; + for ( int i=0; iDrawFilledRect( Gwen::Rect( rect.x + iSpacing * i, rect.y + dist - 2, 1, 5 ) ); + } + } + + void DrawSliderNotchesV( Gwen::Rect rect, int numNotches, int dist ) + { + if ( numNotches == 0 ) return; + + float iSpacing = (float)rect.h / (float)numNotches; + for ( int i=0; iDrawFilledRect( Gwen::Rect( rect.x + dist - 1, rect.y + iSpacing * i, 5, 1 ) ); + } + } + + virtual void DrawSlider( Gwen::Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize ) + { + if ( bIsHorizontal ) + { + Gwen::Rect rect = control->GetRenderBounds(); + rect.x += barSize*0.5; + rect.w -= barSize; + rect.y += rect.h*0.5-1; + rect.h = 1; + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 100 ) ); + DrawSliderNotchesH( rect, numNotches, barSize * 0.5 ); + return GetRender()->DrawFilledRect( rect ); + } + + Gwen::Rect rect = control->GetRenderBounds(); + rect.y += barSize*0.5; + rect.h -= barSize; + rect.x += rect.w*0.5-1; + rect.w = 1; + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 100 ) ); + DrawSliderNotchesV( rect, numNotches, barSize * 0.4 ); + return GetRender()->DrawFilledRect( rect ); + } + + virtual void DrawComboBox( Gwen::Controls::Base* control, bool bDown, bool bMenuOpen ) + { + if ( control->IsDisabled() ) + return Textures.Input.ComboBox.Disabled.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bDown || bMenuOpen ) + return Textures.Input.ComboBox.Down.Draw( GetRender(), control->GetRenderBounds() ); + + if ( control->IsHovered() ) + return Textures.Input.ComboBox.Hover.Draw( GetRender(), control->GetRenderBounds() ); + + Textures.Input.ComboBox.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawKeyboardHighlight( Gwen::Controls::Base* control, const Gwen::Rect& r, int iOffset ) + { + Gwen::Rect rect = r; + + rect.x += iOffset; + rect.y += iOffset; + rect.w -= iOffset*2; + rect.h -= iOffset*2; + + //draw the top and bottom + bool skip = true; + for(int i=0; i< rect.w*0.5; i++) + { + m_Render->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + if (!skip) + { + GetRender()->DrawPixel(rect.x + (i*2), rect.y); + GetRender()->DrawPixel(rect.x + (i*2), rect.y+rect.h-1); + } + else + skip = !skip; + } + skip = false; + for(int i=0; i< rect.h*0.5; i++) + { + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + if (!skip) + { + GetRender()->DrawPixel(rect.x , rect.y +i*2); + GetRender()->DrawPixel(rect.x +rect.w-1, rect.y +i*2 ); + } + else + skip = !skip; + } + } + + virtual void DrawToolTip( Gwen::Controls::Base* control ) + { + return Textures.Tooltip.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawScrollButton( Gwen::Controls::Base* control, int iDirection, bool bDepressed, bool bHovered, bool bDisabled ) + { + int i = 0; + if ( iDirection == Pos::Top ) i = 1; + if ( iDirection == Pos::Right ) i = 2; + if ( iDirection == Pos::Bottom ) i = 3; + + if ( bDisabled ) + return Textures.Scroller.Button.Disabled[i].Draw( GetRender(), control->GetRenderBounds() ); + + if ( bDepressed ) + return Textures.Scroller.Button.Down[i].Draw( GetRender(), control->GetRenderBounds() ); + + if ( bHovered ) + return Textures.Scroller.Button.Hover[i].Draw( GetRender(), control->GetRenderBounds() ); + + return Textures.Scroller.Button.Normal[i].Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawComboDownArrow( Gwen::Controls::Base* control, bool bHovered, bool bDown, bool bMenuOpen, bool bDisabled ) + { + if ( bDisabled ) + return Textures.Input.ComboBox.Button.Disabled.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bDown || bMenuOpen ) + return Textures.Input.ComboBox.Button.Down.Draw( GetRender(), control->GetRenderBounds() ); + + if ( bHovered ) + return Textures.Input.ComboBox.Button.Hover.Draw( GetRender(), control->GetRenderBounds() ); + + Textures.Input.ComboBox.Button.Normal.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawNumericUpDownButton( Gwen::Controls::Base* control, bool bDepressed, bool bUp ) + { + if ( bUp ) + { + if ( control->IsDisabled() ) return Textures.Input.UpDown.Up.Disabled.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( bDepressed ) return Textures.Input.UpDown.Up.Down.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( control->IsHovered() ) return Textures.Input.UpDown.Up.Hover.DrawCenter( GetRender(), control->GetRenderBounds() ); + return Textures.Input.UpDown.Up.Normal.DrawCenter( GetRender(), control->GetRenderBounds() ); + } + + if ( control->IsDisabled() ) return Textures.Input.UpDown.Down.Disabled.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( bDepressed ) return Textures.Input.UpDown.Down.Down.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( control->IsHovered() ) return Textures.Input.UpDown.Down.Hover.DrawCenter( GetRender(), control->GetRenderBounds() ); + return Textures.Input.UpDown.Down.Normal.DrawCenter( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawStatusBar( Controls::Base* control ) + { + Textures.StatusBar.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawTreeButton( Controls::Base* control, bool bOpen ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + if ( bOpen ) + Textures.Tree.Minus.Draw( GetRender(), rect ); + else + Textures.Tree.Plus.Draw( GetRender(), rect ); + } + + void DrawColorDisplay( Controls::Base* control, Gwen::Color color ) + { + Gwen::Rect rect = control->GetRenderBounds(); + + if ( color.a != 255) + { + GetRender()->SetDrawColor( Gwen::Color( 255, 255, 255, 255 ) ); + GetRender()->DrawFilledRect( rect ); + + GetRender()->SetDrawColor( Gwen::Color( 128, 128, 128, 128 ) ); + + GetRender()->DrawFilledRect( Gwen::Rect( 0, 0, rect.w * 0.5, rect.h * 0.5) ); + GetRender()->DrawFilledRect( Gwen::Rect( rect.w * 0.5, rect.h * 0.5, rect.w * 0.5,rect.h * 0.5) ); + } + + GetRender()->SetDrawColor( color ); + GetRender()->DrawFilledRect( rect ); + + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 255 ) ); + GetRender()->DrawLinedRect( rect ); + } + + virtual void DrawModalControl( Controls::Base* control ) + { + if ( !control->ShouldDrawBackground() ) return; + + Gwen::Rect rect = control->GetRenderBounds(); + GetRender()->SetDrawColor( Colors.ModalBackground ); + GetRender()->DrawFilledRect( rect ); + } + + virtual void DrawMenuDivider( Controls::Base* control ) + { + Gwen::Rect rect = control->GetRenderBounds(); + GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 100 ) ); + GetRender()->DrawFilledRect( rect ); + } + + virtual void DrawTreeControl( Controls::Base* control ) + { + Textures.Tree.Background.Draw( GetRender(), control->GetRenderBounds() ); + } + + virtual void DrawWindowCloseButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + Gwen::Rect r = Gwen::Rect( control->GetRenderBounds().x, control->GetRenderBounds().y, 31, 31 ); + + if ( bDisabled ) return Textures.Window.Close.Draw( GetRender(), r, Gwen::Color( 255, 255, 255, 50 ) ); + if ( bDepressed ) return Textures.Window.Close_Down.Draw( GetRender(), r ); + if ( bHovered ) return Textures.Window.Close_Hover.Draw( GetRender(), r ); + + Textures.Window.Close.Draw( GetRender(), r ); + } + + virtual void DrawWindowMaximizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled, bool bMaximized ) + { + Gwen::Rect r = Gwen::Rect( control->GetRenderBounds().x, control->GetRenderBounds().y, 31, 31 ); + + if ( !bMaximized ) + { + if ( bDisabled ) return Textures.Window.Maxi.Draw( GetRender(), r, Gwen::Color( 255, 255, 255, 50 ) ); + if ( bDepressed ) return Textures.Window.Maxi_Down.Draw( GetRender(), r ); + if ( bHovered ) return Textures.Window.Maxi_Hover.Draw( GetRender(), r ); + + return Textures.Window.Maxi.Draw( GetRender(), r ); + } + + if ( bDisabled ) return Textures.Window.Restore.Draw( GetRender(), r, Gwen::Color( 255, 255, 255, 50 ) ); + if ( bDepressed ) return Textures.Window.Restore_Down.Draw( GetRender(), r ); + if ( bHovered ) return Textures.Window.Restore_Hover.Draw( GetRender(), r ); + + return Textures.Window.Restore.Draw( GetRender(), r ); + + } + + virtual void DrawWindowMinimizeButton( Gwen::Controls::Base* control, bool bDepressed, bool bHovered, bool bDisabled ) + { + Gwen::Rect r = Gwen::Rect( control->GetRenderBounds().x, control->GetRenderBounds().y, 31, 31 ); + + if ( bDisabled ) return Textures.Window.Mini.Draw( GetRender(), r, Gwen::Color( 255, 255, 255, 100 ) ); + if ( bDepressed ) return Textures.Window.Mini_Down.Draw( GetRender(), r ); + if ( bHovered ) return Textures.Window.Mini_Hover.Draw( GetRender(), r); + + Textures.Window.Mini.Draw( GetRender(), r ); + } + + + virtual void DrawSlideButton( Gwen::Controls::Base* control, bool bDepressed, bool bHorizontal ) + { + if ( !bHorizontal ) + { + if ( control->IsDisabled() ) return Textures.Input.Slider.V.Disabled.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( bDepressed ) return Textures.Input.Slider.V.Down.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( control->IsHovered() ) return Textures.Input.Slider.V.Hover.DrawCenter( GetRender(), control->GetRenderBounds() ); + + return Textures.Input.Slider.V.Normal.DrawCenter( GetRender(), control->GetRenderBounds() ); + } + + if ( control->IsDisabled() ) return Textures.Input.Slider.H.Disabled.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( bDepressed ) return Textures.Input.Slider.H.Down.DrawCenter( GetRender(), control->GetRenderBounds() ); + if ( control->IsHovered() ) return Textures.Input.Slider.H.Hover.DrawCenter( GetRender(), control->GetRenderBounds() ); + + Textures.Input.Slider.H.Normal.DrawCenter( GetRender(), control->GetRenderBounds() ); + } + + void DrawTreeNode( Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot ) + { + if ( bSelected ) + { + Textures.Selection.Draw( GetRender(), Gwen::Rect( 17, 0, iLabelWidth + 2, iLabelHeight-1 ) ); + } + + Base::DrawTreeNode( ctrl, bOpen, bSelected, iLabelHeight, iLabelWidth, iHalfWay, iLastBranch, bIsRoot ); + } + + void DrawCategoryHolder( Controls::Base* ctrl ) + { + Textures.CategoryList.Outer.Draw( GetRender(), ctrl->GetRenderBounds() ); + } + + void DrawCategoryInner( Controls::Base* ctrl, bool bCollapsed ) + { + if ( bCollapsed ) + return Textures.CategoryList.Header.Draw( GetRender(), ctrl->GetRenderBounds() ); + + Textures.CategoryList.Inner.Draw( GetRender(), ctrl->GetRenderBounds() ); + } + }; + } +} +#endif diff --git a/lib/gwen/skins/gwen_texturing.h b/lib/gwen/skins/gwen_texturing.h new file mode 100644 index 0000000..0cb630d --- /dev/null +++ b/lib/gwen/skins/gwen_texturing.h @@ -0,0 +1,168 @@ +#pragma once +#ifndef GWEN_SKINS_TEXTURING_H +#define GWEN_SKINS_TEXTURING_H + +#include "../gwen.h" +#include "../gwen_texture.h" + +namespace Gwen +{ + namespace Skin + { + namespace Texturing + { + struct Single + { + Single() + { + texture = NULL; + } + + void Init( Texture* pTexture, float x, float y, float w, float h ) + { + texture = pTexture; + + float texw = texture->width; + float texh = texture->height; + + uv[0] = x / texw; + uv[1] = y / texh; + uv[2] = (x+w) / texw; + uv[3] = (y+h) / texh; + + this->iWidth = w; + this->iHeight = h; + } + + void Draw( Gwen::Renderer::Base* render, Gwen::Rect r, const Gwen::Color& col = Gwen::Colors::White ) + { + if ( !texture ) return; + + render->SetDrawColor( col ); + render->DrawTexturedRect( texture, r, uv[0], uv[1],uv[2], uv[3] ); + } + + void DrawCenter( Gwen::Renderer::Base* render, Gwen::Rect r, const Gwen::Color& col = Gwen::Colors::White ) + { + if ( !texture ) return; + + r.x += (r.w - iWidth) * 0.5; + r.y += (r.h - iHeight) * 0.5; + r.w = iWidth; + r.h = iHeight; + + Draw( render, r, col ); + } + + + Texture* texture; + float uv[4]; + int iWidth; + int iHeight; + }; + + struct Bordered + { + Bordered() + { + texture = NULL; + } + + void Init( Texture* pTexture, float x, float y, float w, float h, Margin in_margin, float DrawMarginScale = 1.0f ) + { + texture = pTexture; + + margin = in_margin; + + SetRect( 0, x, y, margin.left, margin.top ); + SetRect( 1, x+margin.left, y, w - margin.left - margin.right, margin.top ); + SetRect( 2, (x + w) - margin.right, y, margin.right, margin.top ); + + SetRect( 3, x, y+margin.top, margin.left, h - margin.top - margin.bottom ); + SetRect( 4, x+margin.left, y+margin.top, w - margin.left - margin.right, h - margin.top - margin.bottom ); + SetRect( 5, (x + w) - margin.right, y+margin.top, margin.right, h - margin.top - margin.bottom ); + + SetRect( 6, x, (y+h)-margin.bottom, margin.left, margin.bottom ); + SetRect( 7, x+margin.left, (y+h)-margin.bottom, w - margin.left - margin.right, margin.bottom ); + SetRect( 8, (x + w) - margin.right, (y+h)-margin.bottom, margin.right, margin.bottom ); + + margin.left *= DrawMarginScale; + margin.right *= DrawMarginScale; + margin.top *= DrawMarginScale; + margin.bottom *= DrawMarginScale; + + width = w - x; + height = h - y; + } + + void SetRect( int iNum, float x, float y, float w, float h ) + { + float texw = texture->width; + float texh = texture->height; + + //x -= 1.0f; + //y -= 1.0f; + + + + rects[iNum].uv[0] = x / texw; + rects[iNum].uv[1] = y / texh; + + rects[iNum].uv[2] = (x+w) / texw; + rects[iNum].uv[3] = (y+h) / texh; + + // rects[iNum].uv[0] += 1.0f / texture->width; + // rects[iNum].uv[1] += 1.0f / texture->width; + } + + void Draw( Gwen::Renderer::Base* render, Gwen::Rect r, const Gwen::Color& col = Gwen::Colors::White, bool b1 = true, bool b2 = true, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true, bool b8 = true, bool b9 = true ) + { + if ( !texture ) return; + + render->SetDrawColor( col ); + + if ( r.w < width && r.h < height ) + { + render->DrawTexturedRect( texture, + r, + rects[0].uv[0], rects[0].uv[1], rects[8].uv[2], rects[8].uv[3] ); + return; + } + + if ( b1 ) DrawRect( render, 0, r.x, r.y, margin.left, margin.top ); + if ( b2 ) DrawRect( render, 1, r.x + margin.left, r.y, r.w - margin.left - margin.right, margin.top ); + if ( b3 ) DrawRect( render, 2, (r.x + r.w) - margin.right, r.y, margin.right, margin.top ); + + if ( b4 ) DrawRect( render, 3, r.x, r.y+margin.top, margin.left, r.h - margin.top - margin.bottom ); + if ( b5 ) DrawRect( render, 4, r.x + margin.left, r.y+margin.top, r.w - margin.left - margin.right, r.h - margin.top - margin.bottom ); + if ( b6 ) DrawRect( render, 5, (r.x + r.w) - margin.right, r.y+margin.top, margin.right, r.h - margin.top - margin.bottom ); + + if ( b7 ) DrawRect( render, 6, r.x, (r.y+r.h) - margin.bottom, margin.left, margin.bottom ); + if ( b8 ) DrawRect( render, 7, r.x + margin.left, (r.y+r.h) - margin.bottom, r.w - margin.left - margin.right, margin.bottom ); + if ( b9 ) DrawRect( render, 8, (r.x + r.w) - margin.right, (r.y+r.h) - margin.bottom, margin.right, margin.bottom ); + } + + void DrawRect( Gwen::Renderer::Base* render, int i, int x, int y, int w, int h ) + { + render->DrawTexturedRect( texture, + Gwen::Rect( x, y, w, h ), + rects[i].uv[0], rects[i].uv[1], rects[i].uv[2], rects[i].uv[3] ); + } + + Texture* texture; + + struct SubRect + { + float uv[4]; + }; + + SubRect rects[9]; + Margin margin; + + float width; + float height; + }; + } + } +} +#endif diff --git a/lib/portable-crt/include/crt/snprintf.h b/lib/portable-crt/include/crt/snprintf.h new file mode 100644 index 0000000..f87f9c9 --- /dev/null +++ b/lib/portable-crt/include/crt/snprintf.h @@ -0,0 +1,45 @@ +#ifndef PORTABLE_CRT_SNPRINTF_H_INCLUDED__ +#define PORTABLE_CRT_SNPRINTF_H_INCLUDED__ + +#include +#include + +#if defined(_MSC_VER) && defined(_WIN32) && !defined(snprintf) + +int c99_snprintf(char* str, size_t size, const char* format, ...); +int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap); + +// these functions shamelessly copied from: +// http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 +// they serve to mimic C99 standard snprintf functionality (like the return +// value) on MSVC (which does it's own non-standard thing) + +#define snprintf c99_snprintf + +inline int c99_snprintf(char* str, size_t size, const char* format, ...) +{ + int count; + va_list ap; + + va_start(ap, format); + count = c99_vsnprintf(str, size, format, ap); + va_end(ap); + + return count; +} + +inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap) +{ + int count = -1; + + if (size != 0) + count = _vsnprintf_s(str, size, _TRUNCATE, format, ap); + if (count == -1) + count = _vscprintf(format, ap); + + return count; +} + +#endif + +#endif diff --git a/lib/sdl-osx/SDLMain.h b/lib/sdl-osx/SDLMain.h new file mode 100644 index 0000000..c56d90c --- /dev/null +++ b/lib/sdl-osx/SDLMain.h @@ -0,0 +1,16 @@ +/* SDLMain.m - main entry point for our Cocoa-ized SDL app + Initial Version: Darrell Walisser + Non-NIB-Code & other changes: Max Horn + + Feel free to customize this file to suit your needs +*/ + +#ifndef _SDLMain_h_ +#define _SDLMain_h_ + +#import + +@interface SDLMain : NSObject +@end + +#endif /* _SDLMain_h_ */ diff --git a/lib/sdl-osx/SDLMain.m b/lib/sdl-osx/SDLMain.m new file mode 100644 index 0000000..4ed4853 --- /dev/null +++ b/lib/sdl-osx/SDLMain.m @@ -0,0 +1,383 @@ +/* SDLMain.m - main entry point for our Cocoa-ized SDL app + Initial Version: Darrell Walisser + Non-NIB-Code & other changes: Max Horn + + Feel free to customize this file to suit your needs +*/ + +#include "SDL.h" +#include "SDLMain.h" +#include /* for MAXPATHLEN */ +#include + +/* For some reaon, Apple removed setAppleMenu from the headers in 10.4, + but the method still is there and works. To avoid warnings, we declare + it ourselves here. */ +@interface NSApplication(SDL_Missing_Methods) +- (void)setAppleMenu:(NSMenu *)menu; +@end + +/* Use this flag to determine whether we use SDLMain.nib or not */ +#define SDL_USE_NIB_FILE 0 + +/* Use this flag to determine whether we use CPS (docking) or not */ +#define SDL_USE_CPS 1 +#ifdef SDL_USE_CPS +/* Portions of CPS.h */ +typedef struct CPSProcessSerNum +{ + UInt32 lo; + UInt32 hi; +} CPSProcessSerNum; + +extern OSErr CPSGetCurrentProcess( CPSProcessSerNum *psn); +extern OSErr CPSEnableForegroundOperation( CPSProcessSerNum *psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5); +extern OSErr CPSSetFrontProcess( CPSProcessSerNum *psn); + +#endif /* SDL_USE_CPS */ + +static int gArgc; +static char **gArgv; +static BOOL gFinderLaunch; +static BOOL gCalledAppMainline = FALSE; + +static NSString *getApplicationName(void) +{ + const NSDictionary *dict; + NSString *appName = 0; + + /* Determine the application name */ + dict = (const NSDictionary *)CFBundleGetInfoDictionary(CFBundleGetMainBundle()); + if (dict) + appName = [dict objectForKey: @"CFBundleName"]; + + if (![appName length]) + appName = [[NSProcessInfo processInfo] processName]; + + return appName; +} + +#if SDL_USE_NIB_FILE +/* A helper category for NSString */ +@interface NSString (ReplaceSubString) +- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString; +@end +#endif + +@interface NSApplication (SDLApplication) +@end + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation" +@implementation NSApplication (SDLApplication) +/* Invoked from the Quit menu item */ +- (void)terminate:(id)sender +{ + /* Post a SDL_QUIT event */ + SDL_Event event; + event.type = SDL_QUIT; + SDL_PushEvent(&event); +} +@end +#pragma clang diagnostic pop + +/* The main class of the application, the application's delegate */ +@implementation SDLMain + +/* Set the working directory to the .app's parent directory */ +- (void) setupWorkingDirectory:(BOOL)shouldChdir +{ + if (shouldChdir) + { + char parentdir[MAXPATHLEN]; + CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle()); + CFURLRef url2 = CFURLCreateCopyDeletingLastPathComponent(0, url); + if (CFURLGetFileSystemRepresentation(url2, 1, (UInt8 *)parentdir, MAXPATHLEN)) { + chdir(parentdir); /* chdir to the binary app's parent */ + } + CFRelease(url); + CFRelease(url2); + } +} + +#if SDL_USE_NIB_FILE + +/* Fix menu to contain the real app name instead of "SDL App" */ +- (void)fixMenu:(NSMenu *)aMenu withAppName:(NSString *)appName +{ + NSRange aRange; + NSEnumerator *enumerator; + NSMenuItem *menuItem; + + aRange = [[aMenu title] rangeOfString:@"SDL App"]; + if (aRange.length != 0) + [aMenu setTitle: [[aMenu title] stringByReplacingRange:aRange with:appName]]; + + enumerator = [[aMenu itemArray] objectEnumerator]; + while ((menuItem = [enumerator nextObject])) + { + aRange = [[menuItem title] rangeOfString:@"SDL App"]; + if (aRange.length != 0) + [menuItem setTitle: [[menuItem title] stringByReplacingRange:aRange with:appName]]; + if ([menuItem hasSubmenu]) + [self fixMenu:[menuItem submenu] withAppName:appName]; + } +} + +#else + +static void setApplicationMenu(void) +{ + /* warning: this code is very odd */ + NSMenu *appleMenu; + NSMenuItem *menuItem; + NSString *title; + NSString *appName; + + appName = getApplicationName(); + appleMenu = [[NSMenu alloc] initWithTitle:@""]; + + /* Add menu items */ + title = [@"About " stringByAppendingString:appName]; + [appleMenu addItemWithTitle:title action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""]; + + [appleMenu addItem:[NSMenuItem separatorItem]]; + + title = [@"Hide " stringByAppendingString:appName]; + [appleMenu addItemWithTitle:title action:@selector(hide:) keyEquivalent:@"h"]; + + menuItem = (NSMenuItem *)[appleMenu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"]; + [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)]; + + [appleMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""]; + + [appleMenu addItem:[NSMenuItem separatorItem]]; + + title = [@"Quit " stringByAppendingString:appName]; + [appleMenu addItemWithTitle:title action:@selector(terminate:) keyEquivalent:@"q"]; + + + /* Put menu into the menubar */ + menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""]; + [menuItem setSubmenu:appleMenu]; + [[NSApp mainMenu] addItem:menuItem]; + + /* Tell the application object that this is now the application menu */ + [NSApp setAppleMenu:appleMenu]; + + /* Finally give up our references to the objects */ + [appleMenu release]; + [menuItem release]; +} + +/* Create a window menu */ +static void setupWindowMenu(void) +{ + NSMenu *windowMenu; + NSMenuItem *windowMenuItem; + NSMenuItem *menuItem; + + windowMenu = [[NSMenu alloc] initWithTitle:@"Window"]; + + /* "Minimize" item */ + menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"]; + [windowMenu addItem:menuItem]; + [menuItem release]; + + /* Put menu into the menubar */ + windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""]; + [windowMenuItem setSubmenu:windowMenu]; + [[NSApp mainMenu] addItem:windowMenuItem]; + + /* Tell the application object that this is now the window menu */ + [NSApp setWindowsMenu:windowMenu]; + + /* Finally give up our references to the objects */ + [windowMenu release]; + [windowMenuItem release]; +} + +/* Replacement for NSApplicationMain */ +static void CustomApplicationMain (int argc, char **argv) +{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + SDLMain *sdlMain; + + /* Ensure the application object is initialised */ + [NSApplication sharedApplication]; + +#ifdef SDL_USE_CPS + { + CPSProcessSerNum PSN; + /* Tell the dock about us */ + if (!CPSGetCurrentProcess(&PSN)) + if (!CPSEnableForegroundOperation(&PSN,0x03,0x3C,0x2C,0x1103)) + if (!CPSSetFrontProcess(&PSN)) + [NSApplication sharedApplication]; + } +#endif /* SDL_USE_CPS */ + + /* Set up the menubar */ + [NSApp setMainMenu:[[NSMenu alloc] init]]; + setApplicationMenu(); + setupWindowMenu(); + + /* Create SDLMain and make it the app delegate */ + sdlMain = [[SDLMain alloc] init]; + [NSApp setDelegate:sdlMain]; + + /* Start the main event loop */ + [NSApp run]; + + [sdlMain release]; + [pool release]; +} + +#endif + + +/* + * Catch document open requests...this lets us notice files when the app + * was launched by double-clicking a document, or when a document was + * dragged/dropped on the app's icon. You need to have a + * CFBundleDocumentsType section in your Info.plist to get this message, + * apparently. + * + * Files are added to gArgv, so to the app, they'll look like command line + * arguments. Previously, apps launched from the finder had nothing but + * an argv[0]. + * + * This message may be received multiple times to open several docs on launch. + * + * This message is ignored once the app's mainline has been called. + */ +- (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename +{ + const char *temparg; + size_t arglen; + char *arg; + char **newargv; + + if (!gFinderLaunch) /* MacOS is passing command line args. */ + return FALSE; + + if (gCalledAppMainline) /* app has started, ignore this document. */ + return FALSE; + + temparg = [filename UTF8String]; + arglen = SDL_strlen(temparg) + 1; + arg = (char *) SDL_malloc(arglen); + if (arg == NULL) + return FALSE; + + newargv = (char **) realloc(gArgv, sizeof (char *) * (gArgc + 2)); + if (newargv == NULL) + { + SDL_free(arg); + return FALSE; + } + gArgv = newargv; + + SDL_strlcpy(arg, temparg, arglen); + gArgv[gArgc++] = arg; + gArgv[gArgc] = NULL; + return TRUE; +} + + +/* Called when the internal event loop has just started running */ +- (void) applicationDidFinishLaunching: (NSNotification *) note +{ + int status; + + /* Set the working directory to the .app's parent directory */ + [self setupWorkingDirectory:gFinderLaunch]; + +#if SDL_USE_NIB_FILE + /* Set the main menu to contain the real app name instead of "SDL App" */ + [self fixMenu:[NSApp mainMenu] withAppName:getApplicationName()]; +#endif + + /* Hand off to main application code */ + gCalledAppMainline = TRUE; + status = SDL_main (gArgc, gArgv); + + /* We're done, thank you for playing */ + exit(status); +} +@end + + +@implementation NSString (ReplaceSubString) + +- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString +{ + unsigned int bufferSize; + unsigned int selfLen = [self length]; + unsigned int aStringLen = [aString length]; + unichar *buffer; + NSRange localRange; + NSString *result; + + bufferSize = selfLen + aStringLen - aRange.length; + buffer = (unichar *)NSAllocateMemoryPages(bufferSize*sizeof(unichar)); + + /* Get first part into buffer */ + localRange.location = 0; + localRange.length = aRange.location; + [self getCharacters:buffer range:localRange]; + + /* Get middle part into buffer */ + localRange.location = 0; + localRange.length = aStringLen; + [aString getCharacters:(buffer+aRange.location) range:localRange]; + + /* Get last part into buffer */ + localRange.location = aRange.location + aRange.length; + localRange.length = selfLen - localRange.location; + [self getCharacters:(buffer+aRange.location+aStringLen) range:localRange]; + + /* Build output string */ + result = [NSString stringWithCharacters:buffer length:bufferSize]; + + NSDeallocateMemoryPages(buffer, bufferSize); + + return result; +} + +@end + + + +#ifdef main +# undef main +#endif + + +/* Main entry point to executable - should *not* be SDL_main! */ +int main (int argc, char **argv) +{ + /* Copy the arguments into a global variable */ + /* This is passed if we are launched by double-clicking */ + if ( argc >= 2 && strncmp (argv[1], "-psn", 4) == 0 ) { + gArgv = (char **) SDL_malloc(sizeof (char *) * 2); + gArgv[0] = argv[0]; + gArgv[1] = NULL; + gArgc = 1; + gFinderLaunch = YES; + } else { + int i; + gArgc = argc; + gArgv = (char **) SDL_malloc(sizeof (char *) * (argc+1)); + for (i = 0; i <= argc; i++) + gArgv[i] = argv[i]; + gFinderLaunch = NO; + } + +#if SDL_USE_NIB_FILE + NSApplicationMain (argc, argv); +#else + CustomApplicationMain (argc, argv); +#endif + return 0; +} diff --git a/lib/stb/stb_image.c b/lib/stb/stb_image.c new file mode 100644 index 0000000..77c308c --- /dev/null +++ b/lib/stb/stb_image.c @@ -0,0 +1,4684 @@ +/* stbi-1.33 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c + when you control the images you're loading + no warranty implied; use at your own risk + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline (no JPEG progressive) + PNG 8-bit only + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) + + Latest revisions: + 1.33 (2011-07-14) minor fixes suggested by Dave Moore + 1.32 (2011-07-13) info support for all filetypes (SpartanJ) + 1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger) + 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila) + allow trailing 0s at end of image data (Laurent Gomila) + 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ + + See end of file for full revision history. + + TODO: + stbi_info support for BMP,PSD,HDR,PIC + + + ============================ Contributors ========================= + + Image formats Optimizations & bugfixes + Sean Barrett (jpeg, png, bmp) Fabian "ryg" Giesen + Nicolas Schulz (hdr, psd) + Jonathan Dummer (tga) Bug fixes & warning fixes + Jean-Marc Lienher (gif) Marc LeBlanc + Tom Seddon (pic) Christpher Lloyd + Thatcher Ulrich (psd) Dave Moore + Won Chun + the Horde3D community + Extensions, features Janez Zemva + Jetro Lauha (stbi_info) Jonathan Blow + James "moose2000" Brown (iPhone PNG) Laurent Gomila + Ben "Disch" Wenger (io callbacks) Aruelien Pocheville + Martin "SpartanJ" Golini Ryamond Barbiero + David Woo + + + If your name should be here but isn't, let Sean know. + +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// To get a header file for this, either cut and paste the header, +// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and +// then include stb_image.c from it. + +//// begin header file //////////////////////////////////////////////////// +// +// Limitations: +// - no jpeg progressive support +// - non-HDR formats support 8-bit samples only (jpeg, png) +// - no delayed line count (jpeg) -- IJG doesn't support either +// - no 1-bit BMP +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *comp -- outputs # of image components in image file +// int req_comp -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. +// If req_comp is non-zero, *comp has the number of components that _would_ +// have been output otherwise. E.g. if you set req_comp to 4, you will always +// get RGBA output, but you can check *comp to easily see if it's opaque. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *comp will be unchanged. The function stbi_failure_reason() +// can be queried for an extremely brief, end-user unfriendly explanation +// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid +// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB; nominally they +// would silently load as BGR, except the existing code should have just +// failed on such iPhone PNGs. But you can disable this conversion by +// by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through. +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image now supports loading HDR images in general, and currently +// the Radiance .HDR file format, although the support is provided +// generically. You can still load any file through the existing interface; +// if you attempt to load an HDR file, it will be automatically remapped to +// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). + + +#ifndef STBI_NO_STDIO + +#if defined(_MSC_VER) && _MSC_VER >= 0x1400 +#define _CRT_SECURE_NO_WARNINGS // suppress bogus warnings about fopen() +#endif + +#include +#endif + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for req_comp + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; + +#ifdef __cplusplus +extern "C" { +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,unsigned n); // skip the next 'n' bytes + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +extern stbi_uc *stbi_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); + +#ifndef STBI_NO_HDR + extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + + #ifndef STBI_NO_STDIO + extern float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); + extern float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + #endif + + extern float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); + + extern void stbi_hdr_to_ldr_gamma(float gamma); + extern void stbi_hdr_to_ldr_scale(float scale); + + extern void stbi_ldr_to_hdr_gamma(float gamma); + extern void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_HDR + +// stbi_is_hdr is always defined +extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +extern int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +extern int stbi_is_hdr (char const *filename); +extern int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// NOT THREADSAFE +extern const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +extern void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +extern int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +extern int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern int stbi_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); + +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + + +// ZLIB client - used by PNG, available for other purposes + +extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +extern int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +// define faster low-level operations (typically SIMD support) +#ifdef STBI_SIMD +typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize); +// compute an integer IDCT on "input" +// input[x] = data[x] * dequantize[x] +// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride' +// CLAMP results to 0..255 +typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step); +// compute a conversion from YCbCr to RGB +// 'count' pixels +// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B +// y: Y input channel +// cb: Cb input channel; scale/biased to be 0..255 +// cr: Cr input channel; scale/biased to be 0..255 + +extern void stbi_install_idct(stbi_idct_8x8 func); +extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); +#endif // STBI_SIMD + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifndef STBI_HEADER_FILE_ONLY + +#ifndef STBI_NO_HDR +#include // ldexp +#include // strcmp, strtok +#endif + +#ifndef STBI_NO_STDIO +#include +#endif +#include +#include +#include +#include + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +// NOTE: renamed these so that they have a unique prefix (stbi_) because +// some toolchains (e.g. Android SDK, Marmalade) have conflicting +// typedefs. This is actually what stb_truetype does already, so +// this is a net win for consistency! :) +typedef unsigned char stbi_uint8; +typedef unsigned short stbi_uint16; +typedef signed short stbi_int16; +typedef unsigned int stbi_uint32; +typedef signed int stbi_int32; +typedef unsigned int stbi_uint; + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi_uint32)==4 ? 1 : -1]; + +#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE) +#define STBI_NO_WRITE +#endif + +#define STBI_NOTUSED(v) (void)sizeof(v) + +#if defined(_MSC_VER) && !defined(__S3E__) +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +/////////////////////////////////////////////// +// +// stbi struct and start_xxx functions + +// stbi structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi_uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uint8 buffer_start[128]; + + stbi_uint8 *img_buffer, *img_buffer_end; + stbi_uint8 *img_buffer_original; +} stbi; + + +static void refill_buffer(stbi *s); + +// initialize a memory-decode context +static void start_mem(stbi *s, stbi_uint8 const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (stbi_uint8 *) buffer; + s->img_buffer_end = (stbi_uint8 *) buffer+len; +} + +// initialize a callback-based context +static void start_callbacks(stbi *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->img_buffer_original = s->buffer_start; + refill_buffer(s); +} + +#ifndef STBI_NO_STDIO + +static int stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stdio_skip(void *user, unsigned n) +{ + fseek((FILE*) user, n, SEEK_CUR); +} + +static int stdio_eof(void *user) +{ + return feof((FILE*) user); +} + +static stbi_io_callbacks stbi_stdio_callbacks = +{ + stdio_read, + stdio_skip, + stdio_eof, +}; + +static void start_file(stbi *s, FILE *f) +{ + start_callbacks(s, &stbi_stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi_rewind(stbi *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; +} + +static int stbi_jpeg_test(stbi *s); +static stbi_uc *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp); +static int stbi_png_test(stbi *s); +static stbi_uc *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_png_info(stbi *s, int *x, int *y, int *comp); +static int stbi_bmp_test(stbi *s); +static stbi_uc *stbi_bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_tga_test(stbi *s); +static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_tga_info(stbi *s, int *x, int *y, int *comp); +static int stbi_psd_test(stbi *s); +static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_hdr_test(stbi *s); +static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_pic_test(stbi *s); +static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_gif_test(stbi *s); +static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp); +static int stbi_gif_info(stbi *s, int *x, int *y, int *comp); + + +// this is not threadsafe +static const char *failure_reason; + +const char *stbi_failure_reason(void) +{ + return failure_reason; +} + +static int e(const char *str) +{ + failure_reason = str; + return 0; +} + +// e - error +// epf - error returning pointer to float +// epuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define e(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define e(x,y) e(y) +#else + #define e(x,y) e(x) +#endif + +#define epf(x,y) ((float *) (e(x,y)?NULL:NULL)) +#define epuc(x,y) ((unsigned char *) (e(x,y)?NULL:NULL)) + +void stbi_image_free(void *retval_from_stbi_load) +{ + free(retval_from_stbi_load); +} + +#ifndef STBI_NO_HDR +static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static unsigned char *stbi_load_main(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + if (stbi_jpeg_test(s)) return stbi_jpeg_load(s,x,y,comp,req_comp); + if (stbi_png_test(s)) return stbi_png_load(s,x,y,comp,req_comp); + if (stbi_bmp_test(s)) return stbi_bmp_load(s,x,y,comp,req_comp); + if (stbi_gif_test(s)) return stbi_gif_load(s,x,y,comp,req_comp); + if (stbi_psd_test(s)) return stbi_psd_load(s,x,y,comp,req_comp); + if (stbi_pic_test(s)) return stbi_pic_load(s,x,y,comp,req_comp); + + #ifndef STBI_NO_HDR + if (stbi_hdr_test(s)) { + float *hdr = stbi_hdr_load(s, x,y,comp,req_comp); + return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + // test tga last because it's a crappy test! + if (stbi_tga_test(s)) + return stbi_tga_load(s,x,y,comp,req_comp); + return epuc("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = fopen(filename, "rb"); + unsigned char *result; + if (!f) return epuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s,f); + return stbi_load_main(&s,x,y,comp,req_comp); +} +#endif //!STBI_NO_STDIO + +unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s,buffer,len); + return stbi_load_main(&s,x,y,comp,req_comp); +} + +unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi_load_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_HDR + +float *stbi_loadf_main(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi_hdr_test(s)) + return stbi_hdr_load(s,x,y,comp,req_comp); + #endif + data = stbi_load_main(s, x, y, comp, req_comp); + if (data) + return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return epf("unknown image type", "Image not of any known type, or corrupt"); +} + +float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s,buffer,len); + return stbi_loadf_main(&s,x,y,comp,req_comp); +} + +float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi_loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = fopen(filename, "rb"); + float *result; + if (!f) return epf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s,f); + return stbi_loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_HDR + +// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is +// defined, for API simplicity; if STBI_NO_HDR is defined, it always +// reports false! + +int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi s; + start_mem(&s,buffer,len); + return stbi_hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +extern int stbi_is_hdr (char const *filename) +{ + FILE *f = fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +extern int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + stbi s; + start_file(&s,f); + return stbi_hdr_test(&s); + #else + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi s; + start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi_hdr_test(&s); + #else + return 0; + #endif +} + +#ifndef STBI_NO_HDR +static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f; +static float l2h_gamma=2.2f, l2h_scale=1.0f; + +void stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; } +void stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; } + +void stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; } +void stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; } +#endif + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + SCAN_load=0, + SCAN_type, + SCAN_header +}; + +static void refill_buffer(stbi *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + if (n == 0) { + // at end of file, treat same as if from memory + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_end-1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static int get8(stbi *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int at_eof(stbi *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} + +stbi_inline static stbi_uint8 get8u(stbi *s) +{ + return (stbi_uint8) get8(s); +} + +static void skip(stbi *s, int n) +{ + if (s->io.read) { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int getn(stbi *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} + +static int get16(stbi *s) +{ + int z = get8(s); + return (z << 8) + get8(s); +} + +static stbi_uint32 get32(stbi *s) +{ + stbi_uint32 z = get16(s); + return (z << 16) + get16(s); +} + +static int get16le(stbi *s) +{ + int z = get8(s); + return z + (get8(s) << 8); +} + +static stbi_uint32 get32le(stbi *s) +{ + stbi_uint32 z = get16le(s); + return z + (get16le(s) << 16); +} + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uint8 compute_y(int r, int g, int b) +{ + return (stbi_uint8) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, stbi_uint x, stbi_uint y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + assert(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) malloc(req_comp * x * y); + if (good == NULL) { + free(data); + return epuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define COMBO(a,b) ((a)*8+(b)) + #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (COMBO(img_n, req_comp)) { + CASE(1,2) dest[0]=src[0], dest[1]=255; break; + CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break; + CASE(2,1) dest[0]=src[0]; break; + CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break; + CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break; + CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break; + CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break; + CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break; + CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break; + CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break; + default: assert(0); + } + #undef CASE + } + + free(data); + return good; +} + +#ifndef STBI_NO_HDR +static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output = (float *) malloc(x * y * comp * sizeof(float)); + if (output == NULL) { free(data); return epf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale; + } + if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; + } + free(data); + return output; +} + +#define float2int(x) ((int) (x)) +static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output = (stbi_uc *) malloc(x * y * comp); + if (output == NULL) { free(data); return epuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uint8) float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uint8) float2int(z); + } + } + free(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation) +// +// simple implementation +// - channel subsampling of at most 2 in each dimension +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - uses a lot of intermediate memory, could cache poorly +// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4 +// stb_jpeg: 1.34 seconds (MSVC6, default release build) +// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro) +// IJL11.dll: 1.08 seconds (compiled by intel) +// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG) +// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro) + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uint8 fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi_uint16 code[256]; + stbi_uint8 values[256]; + stbi_uint8 size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} huffman; + +typedef struct +{ + #ifdef STBI_SIMD + unsigned short dequant2[4][64]; + #endif + stbi *s; + huffman huff_dc[4]; + huffman huff_ac[4]; + stbi_uint8 dequant[4][64]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uint8 *data; + void *raw_data; + stbi_uint8 *linebuf; + } img_comp[4]; + + stbi_uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int scan_n, order[4]; + int restart_interval, todo; +} jpeg; + +static int build_huffman(huffman *h, int *count) +{ + int i,j,k=0,code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uint8) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi_uint16) (code++); + if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uint8) i; + } + } + } + return 1; +} + +static void grow_buffer_unsafe(jpeg *j) +{ + do { + int b = j->nomore ? 0 : get8(j->s); + if (b == 0xff) { + int c = get8(j->s); + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static stbi_uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int decode(jpeg *j, huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k]; + assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// combined JPEG 'receive' and JPEG 'extend', since baseline +// always extends everything it receives. +stbi_inline static int extend_receive(jpeg *j, int n) +{ + unsigned int m = 1 << (n-1); + unsigned int k; + if (j->code_bits < n) grow_buffer_unsafe(j); + + #if 1 + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~bmask[n]; + k &= bmask[n]; + j->code_bits -= n; + #else + k = (j->code_buffer >> (32 - n)) & bmask[n]; + j->code_bits -= n; + j->code_buffer <<= n; + #endif + // the following test is probably a random branch that won't + // predict well. I tried to table accelerate it but failed. + // maybe it's compiling as a conditional move? + if (k < m) + return (-1 << n) + k + 1; + else + return k; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static stbi_uint8 dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b) +{ + int diff,dc,k; + int t = decode(j, hdc); + if (t < 0) return e("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) dc; + + // decode AC components, see JPEG spec + k = 1; + do { + int r,s; + int rs = decode(j, hac); + if (rs < 0) return e("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + data[dezigzag[k++]] = (short) extend_receive(j,s); + } + } while (k < 64); + return 1; +} + +// take a -128..127 value and clamp it and convert to 0..255 +stbi_inline static stbi_uint8 clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uint8) x; +} + +#define f2f(x) (int) (((x) * 4096 + 0.5)) +#define fsh(x) ((x) << 12) + +// derived from jidctint -- DCT_ISLOW +#define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * f2f(0.5411961f); \ + t2 = p1 + p3*f2f(-1.847759065f); \ + t3 = p1 + p2*f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = fsh(p2+p3); \ + t1 = fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*f2f( 1.175875602f); \ + t0 = t0*f2f( 0.298631336f); \ + t1 = t1*f2f( 2.053119869f); \ + t2 = t2*f2f( 3.072711026f); \ + t3 = t3*f2f( 1.501321110f); \ + p1 = p5 + p1*f2f(-0.899976223f); \ + p2 = p5 + p2*f2f(-2.562915447f); \ + p3 = p3*f2f(-1.961570560f); \ + p4 = p4*f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +#ifdef STBI_SIMD +typedef unsigned short stbi_dequantize_t; +#else +typedef stbi_uint8 stbi_dequantize_t; +#endif + +// .344 seconds on 3*anemones.jpg +static void idct_block(stbi_uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize) +{ + int i,val[64],*v=val; + stbi_dequantize_t *dq = dequantize; + stbi_uint8 *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d,++dq, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0] * dq[0] << 2; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24], + d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = clamp((x0+t3) >> 17); + o[7] = clamp((x0-t3) >> 17); + o[1] = clamp((x1+t2) >> 17); + o[6] = clamp((x1-t2) >> 17); + o[2] = clamp((x2+t1) >> 17); + o[5] = clamp((x2-t1) >> 17); + o[3] = clamp((x3+t0) >> 17); + o[4] = clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SIMD +static stbi_idct_8x8 stbi_idct_installed = idct_block; + +void stbi_install_idct(stbi_idct_8x8 func) +{ + stbi_idct_installed = func; +} +#endif + +#define MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uint8 get_marker(jpeg *j) +{ + stbi_uint8 x; + if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; } + x = get8u(j->s); + if (x != 0xff) return MARKER_none; + while (x == 0xff) + x = get8u(j->s); + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, reset the entropy decoder and +// the dc prediction +static void reset(jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; + j->marker = MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int parse_entropy_coded_data(jpeg *z) +{ + reset(z); + if (z->scan_n == 1) { + int i,j; + #ifdef STBI_SIMD + __declspec(align(16)) + #endif + short data[64]; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; + #ifdef STBI_SIMD + stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); + #else + idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); + #endif + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) return 1; + reset(z); + } + } + } + } else { // interleaved! + int i,j,k,x,y; + short data[64]; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; + #ifdef STBI_SIMD + stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); + #else + idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); + #endif + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) return 1; + reset(z); + } + } + } + } + return 1; +} + +static int process_marker(jpeg *z, int m) +{ + int L; + switch (m) { + case MARKER_none: // no marker found + return e("expected marker","Corrupt JPEG"); + + case 0xC2: // SOF - progressive + return e("progressive jpeg","JPEG format not supported (progressive)"); + + case 0xDD: // DRI - specify restart interval + if (get16(z->s) != 4) return e("bad DRI len","Corrupt JPEG"); + z->restart_interval = get16(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = get16(z->s)-2; + while (L > 0) { + int q = get8(z->s); + int p = q >> 4; + int t = q & 15,i; + if (p != 0) return e("bad DQT type","Corrupt JPEG"); + if (t > 3) return e("bad DQT table","Corrupt JPEG"); + for (i=0; i < 64; ++i) + z->dequant[t][dezigzag[i]] = get8u(z->s); + #ifdef STBI_SIMD + for (i=0; i < 64; ++i) + z->dequant2[t][i] = z->dequant[t][i]; + #endif + L -= 65; + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = get16(z->s)-2; + while (L > 0) { + stbi_uint8 *v; + int sizes[16],i,m=0; + int q = get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = get8(z->s); + m += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < m; ++i) + v[i] = get8u(z->s); + L -= m; + } + return L==0; + } + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + skip(z->s, get16(z->s)-2); + return 1; + } + return 0; +} + +// after we see SOS +static int process_scan_header(jpeg *z) +{ + int i; + int Ls = get16(z->s); + z->scan_n = get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return e("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = get8(z->s), which; + int q = get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG"); + get8(z->s); // should be 63, but might be 0 + if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG"); + + return 1; +} + +static int process_frame_header(jpeg *z, int scan) +{ + stbi *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = get16(s); if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG + p = get8(s); if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = get16(s); if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = get16(s); if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires + c = get8(s); + if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG"); // JFIF requires + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return e("bad SOF len","Corrupt JPEG"); + + for (i=0; i < s->img_n; ++i) { + z->img_comp[i].id = get8(s); + if (z->img_comp[i].id != i+1) // JFIF requires + if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files! + return e("bad component ID","Corrupt JPEG"); + q = get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG"); + z->img_comp[i].tq = get8(s); if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG"); + } + + if (scan != SCAN_load) return 1; + + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); + if (z->img_comp[i].raw_data == NULL) { + for(--i; i >= 0; --i) { + free(z->img_comp[i].raw_data); + z->img_comp[i].data = NULL; + } + return e("outofmem", "Out of memory"); + } + // align blocks for installable-idct using mmx/sse + z->img_comp[i].data = (stbi_uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].linebuf = NULL; + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define DNL(x) ((x) == 0xdc) +#define SOI(x) ((x) == 0xd8) +#define EOI(x) ((x) == 0xd9) +#define SOF(x) ((x) == 0xc0 || (x) == 0xc1) +#define SOS(x) ((x) == 0xda) + +static int decode_jpeg_header(jpeg *z, int scan) +{ + int m; + z->marker = MARKER_none; // initialize cached marker to empty + m = get_marker(z); + if (!SOI(m)) return e("no SOI","Corrupt JPEG"); + if (scan == SCAN_type) return 1; + m = get_marker(z); + while (!SOF(m)) { + if (!process_marker(z,m)) return 0; + m = get_marker(z); + while (m == MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (at_eof(z->s)) return e("no SOF", "Corrupt JPEG"); + m = get_marker(z); + } + } + if (!process_frame_header(z, scan)) return 0; + return 1; +} + +static int decode_jpeg_image(jpeg *j) +{ + int m; + j->restart_interval = 0; + if (!decode_jpeg_header(j, SCAN_load)) return 0; + m = get_marker(j); + while (!EOI(m)) { + if (SOS(m)) { + if (!process_scan_header(j)) return 0; + if (!parse_entropy_coded_data(j)) return 0; + if (j->marker == MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!at_eof(j->s)) { + int x = get8(j->s); + if (x == 255) { + j->marker = get8u(j->s); + break; + } else if (x != 0) { + return 0; + } + } + // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0 + } + } else { + if (!process_marker(j, m)) return 0; + } + m = get_marker(j); + } + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uint8 *(*resample_row_func)(stbi_uint8 *out, stbi_uint8 *in0, stbi_uint8 *in1, + int w, int hs); + +#define div4(x) ((stbi_uint8) ((x) >> 2)) + +static stbi_uint8 *resample_row_1(stbi_uint8 *out, stbi_uint8 *in_near, stbi_uint8 *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uint8* resample_row_v_2(stbi_uint8 *out, stbi_uint8 *in_near, stbi_uint8 *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uint8* resample_row_h_2(stbi_uint8 *out, stbi_uint8 *in_near, stbi_uint8 *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uint8 *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = div4(n+input[i-1]); + out[i*2+1] = div4(n+input[i+1]); + } + out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define div16(x) ((stbi_uint8) ((x) >> 4)) + +static stbi_uint8 *resample_row_hv_2(stbi_uint8 *out, stbi_uint8 *in_near, stbi_uint8 *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = div16(3*t0 + t1 + 8); + out[i*2 ] = div16(3*t1 + t0 + 8); + } + out[w*2-1] = div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +static stbi_uint8 *resample_row_generic(stbi_uint8 *out, stbi_uint8 *in_near, stbi_uint8 *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + //in_far = in_far; + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +#define float2fixed(x) ((int) ((x) * 65536 + 0.5)) + +// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro) +// VC6 without processor=Pro is generating multiple LEAs per multiply! +static void YCbCr_to_RGB_row(stbi_uint8 *out, const stbi_uint8 *y, const stbi_uint8 *pcb, const stbi_uint8 *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 16) + 32768; // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr*float2fixed(1.40200f); + g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f); + b = y_fixed + cb*float2fixed(1.77200f); + r >>= 16; + g >>= 16; + b >>= 16; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uint8)r; + out[1] = (stbi_uint8)g; + out[2] = (stbi_uint8)b; + out[3] = 255; + out += step; + } +} + +#ifdef STBI_SIMD +static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row; + +void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func) +{ + stbi_YCbCr_installed = func; +} +#endif + + +// clean up the temporary component buffers +static void cleanup_jpeg(jpeg *j) +{ + int i; + for (i=0; i < j->s->img_n; ++i) { + if (j->img_comp[i].data) { + free(j->img_comp[i].raw_data); + j->img_comp[i].data = NULL; + } + if (j->img_comp[i].linebuf) { + free(j->img_comp[i].linebuf); + j->img_comp[i].linebuf = NULL; + } + } +} + +typedef struct +{ + resample_row_func resample; + stbi_uint8 *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi_resample; + +static stbi_uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n; + // validate req_comp + if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error"); + z->s->img_n = 0; + + // load a jpeg image from whichever source + if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n; + + if (z->s->img_n == 3 && n < 3) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and color-convert + { + int k; + stbi_uint i,j; + stbi_uint8 *output; + stbi_uint8 *coutput[4]; + + stbi_resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi_resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uint8 *) malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2; + else r->resample = resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1); + if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uint8 *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi_resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uint8 *y = coutput[0]; + if (z->s->img_n == 3) { + #ifdef STBI_SIMD + stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n); + #else + YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n); + #endif + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + stbi_uint8 *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255; + } + } + cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n; // report original components, not output + return output; + } +} + +static unsigned char *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + jpeg j; + j.s = s; + return load_jpeg_image(&j, x,y,comp,req_comp); +} + +static int stbi_jpeg_test(stbi *s) +{ + int r; + jpeg j; + j.s = s; + r = decode_jpeg_header(&j, SCAN_type); + stbi_rewind(s); + return r; +} + +static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp) +{ + if (!decode_jpeg_header(j, SCAN_header)) { + stbi_rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n; + return 1; +} + +static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp) +{ + jpeg j; + j.s = s; + return stbi_jpeg_info_raw(&j, x, y, comp); +} + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define ZFAST_BITS 9 // accelerate all cases in default tables +#define ZFAST_MASK ((1 << ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi_uint16 fast[1 << ZFAST_BITS]; + stbi_uint16 firstcode[16]; + int maxcode[17]; + stbi_uint16 firstsymbol[16]; + stbi_uint8 size[288]; + stbi_uint16 value[288]; +} zhuffman; + +stbi_inline static int bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int bit_reverse(int v, int bits) +{ + assert(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return bitreverse16(v) >> (16-bits); +} + +static int zbuild_huffman(zhuffman *z, stbi_uint8 *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 255, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + assert(sizes[i] <= (1 << i)); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi_uint16) code; + z->firstsymbol[i] = (stbi_uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + z->size[c] = (stbi_uint8)s; + z->value[c] = (stbi_uint16)i; + if (s <= ZFAST_BITS) { + int k = bit_reverse(next_code[s],s); + while (k < (1 << ZFAST_BITS)) { + z->fast[k] = (stbi_uint16) c; + k += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uint8 *zbuffer, *zbuffer_end; + int num_bits; + stbi_uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + zhuffman z_length, z_distance; +} zbuf; + +stbi_inline static int zget8(zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void fill_bits(zbuf *z) +{ + do { + assert(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int zreceive(zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z) +{ + int b,s,k; + if (a->num_bits < 16) fill_bits(a); + b = z->fast[a->code_buffer & ZFAST_MASK]; + if (b < 0xffff) { + s = z->size[b]; + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; + } + + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = bit_reverse(a->code_buffer, 16); + for (s=ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + assert(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +static int expand(zbuf *z, int n) // need to make room for n bytes +{ + char *q; + int cur, limit; + if (!z->z_expandable) return e("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) realloc(z->zout_start, limit); + if (q == NULL) return e("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static int length_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static int length_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static int dist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int parse_huffman_block(zbuf *a) +{ + for(;;) { + int z = zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes + if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0; + *a->zout++ = (char) z; + } else { + stbi_uint8 *p; + int len,dist; + if (z == 256) return 1; + z -= 257; + len = length_base[z]; + if (length_extra[z]) len += zreceive(a, length_extra[z]); + z = zhuffman_decode(a, &a->z_distance); + if (z < 0) return e("bad huffman code","Corrupt PNG"); + dist = dist_base[z]; + if (dist_extra[z]) dist += zreceive(a, dist_extra[z]); + if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG"); + if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0; + p = (stbi_uint8 *) (a->zout - dist); + while (len--) + *a->zout++ = *p++; + } + } +} + +static int compute_huffman_codes(zbuf *a) +{ + static stbi_uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + zhuffman z_codelength; + stbi_uint8 lencodes[286+32+137];//padding for maximum single op + stbi_uint8 codelength_sizes[19]; + int i,n; + + int hlit = zreceive(a,5) + 257; + int hdist = zreceive(a,5) + 1; + int hclen = zreceive(a,4) + 4; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uint8) s; + } + if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < hlit + hdist) { + int c = zhuffman_decode(a, &z_codelength); + assert(c >= 0 && c < 19); + if (c < 16) + lencodes[n++] = (stbi_uint8) c; + else if (c == 16) { + c = zreceive(a,2)+3; + memset(lencodes+n, lencodes[n-1], c); + n += c; + } else if (c == 17) { + c = zreceive(a,3)+3; + memset(lencodes+n, 0, c); + n += c; + } else { + assert(c == 18); + c = zreceive(a,7)+11; + memset(lencodes+n, 0, c); + n += c; + } + } + if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG"); + if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int parse_uncompressed_block(zbuf *a) +{ + stbi_uint8 header[4]; + int len,nlen,k; + if (a->num_bits & 7) + zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uint8) (a->code_buffer & 255); // wtf this warns? + a->code_buffer >>= 8; + a->num_bits -= 8; + } + assert(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = (stbi_uint8) zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!expand(a, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int parse_zlib_header(zbuf *a) +{ + int cmf = zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = zget8(a); + if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +// @TODO: should statically initialize these for optimal thread safety +static stbi_uint8 default_length[288], default_distance[32]; +static void init_defaults(void) +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) default_length[i] = 8; + for ( ; i <= 255; ++i) default_length[i] = 9; + for ( ; i <= 279; ++i) default_length[i] = 7; + for ( ; i <= 287; ++i) default_length[i] = 8; + + for (i=0; i <= 31; ++i) default_distance[i] = 5; +} + +int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead +static int parse_zlib(zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = zreceive(a,1); + type = zreceive(a,2); + if (type == 0) { + if (!parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!default_distance[31]) init_defaults(); + if (!zbuild_huffman(&a->z_length , default_length , 288)) return 0; + if (!zbuild_huffman(&a->z_distance, default_distance, 32)) return 0; + } else { + if (!compute_huffman_codes(a)) return 0; + } + if (!parse_huffman_block(a)) return 0; + } + if (stbi_png_partial && a->zout - a->zout_start > 65536) + break; + } while (!final); + return 1; +} + +static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return parse_zlib(a, parse_header); +} + +char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + zbuf a; + char *p = (char *) malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uint8 *) buffer; + a.zbuffer_end = (stbi_uint8 *) buffer + len; + if (do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + zbuf a; + char *p = (char *) malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uint8 *) buffer; + a.zbuffer_end = (stbi_uint8 *) buffer + len; + if (do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (stbi_uint8 *) ibuffer; + a.zbuffer_end = (stbi_uint8 *) ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + zbuf a; + char *p = (char *) malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uint8 *) buffer; + a.zbuffer_end = (stbi_uint8 *) buffer+len; + if (do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (stbi_uint8 *) ibuffer; + a.zbuffer_end = (stbi_uint8 *) ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + + +typedef struct +{ + stbi_uint32 length; + stbi_uint32 type; +} chunk; + +#define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +static chunk get_chunk_header(stbi *s) +{ + chunk c; + c.length = get32(s); + c.type = get32(s); + return c; +} + +static int check_png_header(stbi *s) +{ + static stbi_uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (get8u(s) != png_sig[i]) return e("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi *s; + stbi_uint8 *idata, *expanded, *out; +} png; + + +enum { + F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4, + F_avg_first, F_paeth_first +}; + +static stbi_uint8 first_row_filter[5] = +{ + F_none, F_sub, F_none, F_avg_first, F_paeth_first +}; + +static int paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +// create the png data from post-deflated data +static int create_png_image_raw(png *a, stbi_uint8 *raw, stbi_uint32 raw_len, int out_n, stbi_uint32 x, stbi_uint32 y) +{ + stbi *s = a->s; + stbi_uint32 i,j,stride = x*out_n; + int k; + int img_n = s->img_n; // copy it into a local for later + assert(out_n == s->img_n || out_n == s->img_n+1); + if (stbi_png_partial) y = 1; + a->out = (stbi_uint8 *) malloc(x * y * out_n); + if (!a->out) return e("outofmem", "Out of memory"); + if (!stbi_png_partial) { + if (s->img_x == x && s->img_y == y) { + if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG"); + } else { // interlaced: + if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG"); + } + } + for (j=0; j < y; ++j) { + stbi_uint8 *cur = a->out + stride*j; + stbi_uint8 *prior = cur - stride; + int filter = *raw++; + if (filter > 4) return e("invalid filter","Corrupt PNG"); + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + // handle first pixel explicitly + for (k=0; k < img_n; ++k) { + switch (filter) { + case F_none : cur[k] = raw[k]; break; + case F_sub : cur[k] = raw[k]; break; + case F_up : cur[k] = raw[k] + prior[k]; break; + case F_avg : cur[k] = raw[k] + (prior[k]>>1); break; + case F_paeth : cur[k] = (stbi_uint8) (raw[k] + paeth(0,prior[k],0)); break; + case F_avg_first : cur[k] = raw[k]; break; + case F_paeth_first: cur[k] = raw[k]; break; + } + } + if (img_n != out_n) cur[img_n] = 255; + raw += img_n; + cur += out_n; + prior += out_n; + // this is a little gross, so that we don't switch per-pixel or per-component + if (img_n == out_n) { + #define CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \ + for (k=0; k < img_n; ++k) + switch (filter) { + CASE(F_none) cur[k] = raw[k]; break; + CASE(F_sub) cur[k] = raw[k] + cur[k-img_n]; break; + CASE(F_up) cur[k] = raw[k] + prior[k]; break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break; + CASE(F_paeth) cur[k] = (stbi_uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k-img_n] >> 1); break; + CASE(F_paeth_first) cur[k] = (stbi_uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break; + } + #undef CASE + } else { + assert(img_n+1 == out_n); + #define CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \ + for (k=0; k < img_n; ++k) + switch (filter) { + CASE(F_none) cur[k] = raw[k]; break; + CASE(F_sub) cur[k] = raw[k] + cur[k-out_n]; break; + CASE(F_up) cur[k] = raw[k] + prior[k]; break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break; + CASE(F_paeth) cur[k] = (stbi_uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k-out_n] >> 1); break; + CASE(F_paeth_first) cur[k] = (stbi_uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break; + } + #undef CASE + } + } + return 1; +} + +static int create_png_image(png *a, stbi_uint8 *raw, stbi_uint32 raw_len, int out_n, int interlaced) +{ + stbi_uint8 *final; + int p; + int save; + if (!interlaced) + return create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y); + save = stbi_png_partial; + stbi_png_partial = 0; + + // de-interlacing + final = (stbi_uint8 *) malloc(a->s->img_x * a->s->img_y * out_n); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) { + free(final); + return 0; + } + for (j=0; j < y; ++j) + for (i=0; i < x; ++i) + memcpy(final + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n, + a->out + (j*x+i)*out_n, out_n); + free(a->out); + raw += (x*out_n+1)*y; + raw_len -= (x*out_n+1)*y; + } + } + a->out = final; + + stbi_png_partial = save; + return 1; +} + +static int compute_transparency(png *z, stbi_uint8 tc[3], int out_n) +{ + stbi *s = z->s; + stbi_uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uint8 *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + assert(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int expand_palette(png *a, stbi_uint8 *palette, int len, int pal_img_n) +{ + stbi_uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uint8 *p, *temp_out, *orig = a->out; + + p = (stbi_uint8 *) malloc(pixel_count * pal_img_n); + if (p == NULL) return e("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + free(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi_unpremultiply_on_load = 0; +static int stbi_de_iphone_flag = 0; + +void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply; +} +void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi_de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi_de_iphone(png *z) +{ + stbi *s = z->s; + stbi_uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uint8 *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + assert(s->img_out_n == 4); + if (stbi_unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uint8 a = p[3]; + stbi_uint8 t = p[0]; + if (a) { + p[0] = p[2] * 255 / a; + p[1] = p[1] * 255 / a; + p[2] = t * 255 / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +static int parse_png_file(png *z, int scan, int req_comp) +{ + stbi_uint8 palette[1024], pal_img_n=0; + stbi_uint8 has_trans=0, tc[3]; + stbi_uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, iphone=0; + stbi *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!check_png_header(s)) return 0; + + if (scan == SCAN_type) return 1; + + for (;;) { + chunk c = get_chunk_header(s); + switch (c.type) { + case PNG_TYPE('C','g','B','I'): + iphone = stbi_de_iphone_flag; + skip(s, c.length); + break; + case PNG_TYPE('I','H','D','R'): { + int depth,color,comp,filter; + if (!first) return e("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return e("bad IHDR len","Corrupt PNG"); + s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)"); + s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)"); + depth = get8(s); if (depth != 8) return e("8bit only","PNG not supported: 8-bit only"); + color = get8(s); if (color > 6) return e("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG"); + comp = get8(s); if (comp) return e("bad comp method","Corrupt PNG"); + filter= get8(s); if (filter) return e("bad filter method","Corrupt PNG"); + interlace = get8(s); if (interlace>1) return e("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return e("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode"); + if (scan == SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return e("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case PNG_TYPE('P','L','T','E'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = get8u(s); + palette[i*4+1] = get8u(s); + palette[i*4+2] = get8u(s); + palette[i*4+3] = 255; + } + break; + } + + case PNG_TYPE('t','R','N','S'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (z->idata) return e("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = get8u(s); + } else { + if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi_uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); + has_trans = 1; + for (k=0; k < s->img_n; ++k) + tc[k] = (stbi_uint8) get16(s); // non 8-bit images will be larger + } + break; + } + + case PNG_TYPE('I','D','A','T'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG"); + if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; } + if (ioff + c.length > idata_limit) { + stbi_uint8 *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + p = (stbi_uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); + z->idata = p; + } + if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case PNG_TYPE('I','E','N','D'): { + stbi_uint32 raw_len; + if (first) return e("first not IHDR", "Corrupt PNG"); + if (scan != SCAN_load) return 1; + if (z->idata == NULL) return e("no IDAT","Corrupt PNG"); + z->expanded = (stbi_uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone); + if (z->expanded == NULL) return 0; // zlib should set error + free(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0; + if (has_trans) + if (!compute_transparency(z, tc, s->img_out_n)) return 0; + if (iphone && s->img_out_n > 2) + stbi_de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!expand_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } + free(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return e("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX chunk not known"; + invalid_chunk[0] = (stbi_uint8) (c.type >> 24); + invalid_chunk[1] = (stbi_uint8) (c.type >> 16); + invalid_chunk[2] = (stbi_uint8) (c.type >> 8); + invalid_chunk[3] = (stbi_uint8) (c.type >> 0); + #endif + return e(invalid_chunk, "PNG not supported: unknown chunk type"); + } + skip(s, c.length); + break; + } + // end of chunk, read and skip CRC + get32(s); + } +} + +static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp) +{ + unsigned char *result=NULL; + if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error"); + if (parse_png_file(p, SCAN_load, req_comp)) { + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + result = convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + free(p->out); p->out = NULL; + free(p->expanded); p->expanded = NULL; + free(p->idata); p->idata = NULL; + + return result; +} + +static unsigned char *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + png p; + p.s = s; + return do_png(&p, x,y,comp,req_comp); +} + +static int stbi_png_test(stbi *s) +{ + int r; + r = check_png_header(s); + stbi_rewind(s); + return r; +} + +static int stbi_png_info_raw(png *p, int *x, int *y, int *comp) +{ + if (!parse_png_file(p, SCAN_header, 0)) { + stbi_rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi_png_info(stbi *s, int *x, int *y, int *comp) +{ + png p; + p.s = s; + return stbi_png_info_raw(&p, x, y, comp); +} + +// Microsoft/Windows BMP image + +static int bmp_test(stbi *s) +{ + int sz; + if (get8(s) != 'B') return 0; + if (get8(s) != 'M') return 0; + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + get32le(s); // discard data offset + sz = get32le(s); + if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1; + return 0; +} + +static int stbi_bmp_test(stbi *s) +{ + int r = bmp_test(s); + stbi_rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) n += 16, z >>= 16; + if (z >= 0x00100) n += 8, z >>= 8; + if (z >= 0x00010) n += 4, z >>= 4; + if (z >= 0x00004) n += 2, z >>= 2; + if (z >= 0x00002) n += 1, z >>= 1; + return n; +} + +static int bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +static int shiftsigned(int v, int shift, int bits) +{ + int result; + int z=0; + + if (shift < 0) v <<= -shift; + else v >>= shift; + result = v; + + z = bits; + while (z < 8) { + result += v >> z; + z += bits; + } + return result; +} + +static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uint8 *out; + unsigned int mr=0,mg=0,mb=0,ma=0/*, fake_a=0*/; + stbi_uc pal[256][4]; + int psize=0,i,j,compress=0,width; + int bpp, flip_vertically, pad, target, offset, hsz; + if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP"); + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + offset = get32le(s); + hsz = get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = get16le(s); + s->img_y = get16le(s); + } else { + s->img_x = get32le(s); + s->img_y = get32le(s); + } + if (get16le(s) != 1) return epuc("bad BMP", "bad BMP"); + bpp = get16le(s); + if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit"); + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + if (hsz == 12) { + if (bpp < 24) + psize = (offset - 14 - 24) / 3; + } else { + compress = get32le(s); + if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE"); + get32le(s); // discard sizeof + get32le(s); // discard hres + get32le(s); // discard vres + get32le(s); // discard colorsused + get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + get32le(s); + get32le(s); + get32le(s); + get32le(s); + } + if (bpp == 16 || bpp == 32) { + mr = mg = mb = 0; + if (compress == 0) { + if (bpp == 32) { + mr = 0xffu << 16; + mg = 0xffu << 8; + mb = 0xffu << 0; + ma = 0xffu << 24; + //fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255 + } else { + mr = 31u << 10; + mg = 31u << 5; + mb = 31u << 0; + } + } else if (compress == 3) { + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (mr == mg && mg == mb) { + // ?!?!? + return epuc("bad BMP", "bad BMP"); + } + } else + return epuc("bad BMP", "bad BMP"); + } + } else { + assert(hsz == 108); + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + ma = get32le(s); + get32le(s); // discard color space + for (i=0; i < 12; ++i) + get32le(s); // discard color space parameters + } + if (bpp < 16) + psize = (offset - 14 - hsz) >> 2; + } + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + out = (stbi_uc *) malloc(target * s->img_x * s->img_y); + if (!out) return epuc("outofmem", "Out of memory"); + if (bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + if (hsz != 12) get8(s); + pal[i][3] = 255; + } + skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); + if (bpp == 4) width = (s->img_x + 1) >> 1; + else if (bpp == 8) width = s->img_x; + else { free(out); return epuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=get8(s),v2=0; + if (bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (bpp == 8) ? get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + skip(s, pad); + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + skip(s, offset - 14 - hsz); + if (bpp == 24) width = 3 * s->img_x; + else if (bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (bpp == 24) { + easy = 1; + } else if (bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { free(out); return epuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = high_bit(mr)-7; rcount = bitcount(mr); + gshift = high_bit(mg)-7; gcount = bitcount(mr); + bshift = high_bit(mb)-7; bcount = bitcount(mr); + ashift = high_bit(ma)-7; acount = bitcount(mr); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + int a; + out[z+2] = get8u(s); + out[z+1] = get8u(s); + out[z+0] = get8u(s); + z += 3; + a = (easy == 2 ? get8(s) : 255); + if (target == 4) out[z++] = (stbi_uint8) a; + } + } else { + for (i=0; i < (int) s->img_x; ++i) { + stbi_uint32 v = (bpp == 16 ? get16le(s) : get32le(s)); + int a; + out[z++] = (stbi_uint8) shiftsigned(v & mr, rshift, rcount); + out[z++] = (stbi_uint8) shiftsigned(v & mg, gshift, gcount); + out[z++] = (stbi_uint8) shiftsigned(v & mb, bshift, bcount); + a = (ma ? shiftsigned(v & ma, ashift, acount) : 255); + if (target == 4) out[z++] = (stbi_uint8) a; + } + } + skip(s, pad); + } + } + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i], p1[i] = p2[i], p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} + +static stbi_uc *stbi_bmp_load(stbi *s,int *x, int *y, int *comp, int req_comp) +{ + return bmp_load(s, x,y,comp,req_comp); +} + + +// Targa Truevision - TGA +// by Jonathan Dummer + +static int tga_info(stbi *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp; + int sz; + get8u(s); // discard Offset + sz = get8u(s); // color type + if( sz > 1 ) { + stbi_rewind(s); + return 0; // only RGB or indexed allowed + } + sz = get8u(s); // image type + // only RGB or grey allowed, +/- RLE + if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0; + skip(s,9); + tga_w = get16le(s); + if( tga_w < 1 ) { + stbi_rewind(s); + return 0; // test width + } + tga_h = get16le(s); + if( tga_h < 1 ) { + stbi_rewind(s); + return 0; // test height + } + sz = get8(s); // bits per pixel + // only RGB or RGBA or grey allowed + if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) { + stbi_rewind(s); + return 0; + } + tga_comp = sz; + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp / 8; + return 1; // seems to have passed everything +} + +int stbi_tga_info(stbi *s, int *x, int *y, int *comp) +{ + return tga_info(s, x, y, comp); +} + +static int tga_test(stbi *s) +{ + int sz; + get8u(s); // discard Offset + sz = get8u(s); // color type + if ( sz > 1 ) return 0; // only RGB or indexed allowed + sz = get8u(s); // image type + if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE + get16(s); // discard palette start + get16(s); // discard palette length + get8(s); // discard bits per palette color entry + get16(s); // discard x origin + get16(s); // discard y origin + if ( get16(s) < 1 ) return 0; // test width + if ( get16(s) < 1 ) return 0; // test height + sz = get8(s); // bits per pixel + if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0; // only RGB or RGBA or grey allowed + return 1; // seems to have passed everything +} + +static int stbi_tga_test(stbi *s) +{ + int res = tga_test(s); + stbi_rewind(s); + return res; +} + +static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + // read in the TGA header stuff + int tga_offset = get8u(s); + int tga_indexed = get8u(s); + int tga_image_type = get8u(s); + int tga_is_RLE = 0; + int tga_palette_start = get16le(s); + int tga_palette_len = get16le(s); + int tga_palette_bits = get8u(s); + int tga_x_origin = get16le(s); + int tga_y_origin = get16le(s); + int tga_width = get16le(s); + int tga_height = get16le(s); + int tga_bits_per_pixel = get8u(s); + int tga_inverted = get8u(s); + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4]; + unsigned char trans_data[4]; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + /* int tga_alpha_bits = tga_inverted & 15; */ + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // error check + if ( //(tga_indexed) || + (tga_width < 1) || (tga_height < 1) || + (tga_image_type < 1) || (tga_image_type > 3) || + ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) && + (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32)) + ) + { + return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA + } + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) + { + tga_bits_per_pixel = tga_palette_bits; + } + + // tga info + *x = tga_width; + *y = tga_height; + if ( (req_comp < 1) || (req_comp > 4) ) + { + // just use whatever the file was + req_comp = tga_bits_per_pixel / 8; + *comp = req_comp; + } else + { + // force a new number of components + *comp = tga_bits_per_pixel/8; + } + tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp ); + if (!tga_data) return epuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + skip(s, tga_offset ); + // do I need to load a palette? + if ( tga_indexed ) + { + // any data to skip? (offset usually = 0) + skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 ); + if (!tga_palette) return epuc("outofmem", "Out of memory"); + if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { + free(tga_data); + free(tga_palette); + return epuc("bad palette", "Corrupt TGA"); + } + } + // load the data + trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0; + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE chunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = get8u(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in 1 byte, then perform the lookup + int pal_idx = get8u(s); + if ( pal_idx >= tga_palette_len ) + { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_bits_per_pixel / 8; + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else + { + // read in the data raw + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = get8u(s); + } + } + // convert raw to the intermediate format + switch (tga_bits_per_pixel) + { + case 8: + // Luminous => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 16: + // Luminous,Alpha => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[1]; + break; + case 24: + // BGR => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 32: + // BGRA => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[3]; + break; + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + // convert to final format + switch (req_comp) + { + case 1: + // RGBA => Luminance + tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]); + break; + case 2: + // RGBA => Luminance,Alpha + tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]); + tga_data[i*req_comp+1] = trans_data[3]; + break; + case 3: + // RGBA => RGB + tga_data[i*req_comp+0] = trans_data[0]; + tga_data[i*req_comp+1] = trans_data[1]; + tga_data[i*req_comp+2] = trans_data[2]; + break; + case 4: + // RGBA => RGBA + tga_data[i*req_comp+0] = trans_data[0]; + tga_data[i*req_comp+1] = trans_data[1]; + tga_data[i*req_comp+2] = trans_data[2]; + tga_data[i*req_comp+3] = trans_data[3]; + break; + } + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * req_comp; + int index2 = (tga_height - 1 - j) * tga_width * req_comp; + for (i = tga_width * req_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + free( tga_palette ); + } + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + // OK, done + return tga_data; +} + +static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + return tga_load(s,x,y,comp,req_comp); +} + + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +static int psd_test(stbi *s) +{ + if (get32(s) != 0x38425053) return 0; // "8BPS" + else return 1; +} + +static int stbi_psd_test(stbi *s) +{ + int r = psd_test(s); + stbi_rewind(s); + return r; +} + +static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + int pixelCount; + int channelCount, compression; + int channel, i, count, len; + int w,h; + stbi_uint8 *out; + + // Check identifier + if (get32(s) != 0x38425053) // "8BPS" + return epuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (get16(s) != 1) + return epuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = get16(s); + if (channelCount < 0 || channelCount > 16) + return epuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = get32(s); + w = get32(s); + + // Make sure the depth is 8 bits. + if (get16(s) != 8) + return epuc("unsupported bit depth", "PSD bit depth is not 8 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (get16(s) != 3) + return epuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + skip(s,get32(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + skip(s, get32(s) ); + + // Skip the reserved data. + skip(s, get32(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = get16(s); + if (compression > 1) + return epuc("bad compression", "PSD has an unknown compression format"); + + // Create the destination image. + out = (stbi_uc *) malloc(4 * w*h); + if (!out) return epuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, + // which we're going to just skip. + skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uint8 *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4; + } else { + // Read the RLE data. + count = 0; + while (count < pixelCount) { + len = get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + count += len; + while (len) { + *p = get8u(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uint8 val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len ^= 0x0FF; + len += 2; + val = get8u(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uint8 *p; + + p = out + channel; + if (channel > channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4; + } else { + // Read the data. + for (i = 0; i < pixelCount; i++) + *p = get8u(s), p += 4; + } + } + } + + if (req_comp && req_comp != 4) { + out = convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // convert_format frees input on failure + } + + if (comp) *comp = channelCount; + *y = h; + *x = w; + + return out; +} + +static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + return psd_load(s,x,y,comp,req_comp); +} + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +static int pic_is4(stbi *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int pic_test(stbi *s) +{ + int i; + + if (!pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + get8(s); + + if (!pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} pic_packet_t; + +static stbi_uc *pic_readval(stbi *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (at_eof(s)) return epuc("bad file","PIC file too short"); + dest[i]=get8u(s); + } + } + + return dest; +} + +static void pic_copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + pic_packet_t packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + pic_packet_t *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return epuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = get8(s); + packet->size = get8u(s); + packet->type = get8u(s); + packet->channel = get8u(s); + + act_comp |= packet->channel; + + if (at_eof(s)) return epuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return epuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return epuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + value[0] = 0; + value[1] = 0; + value[2] = 0; + value[3] = 0; + + count=get8u(s); + if (at_eof(s)) return epuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uint8) left; + + if (!pic_readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = get8(s), i; + if (at_eof(s)) return epuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + int i; + + value[0] = 0; + value[1] = 0; + value[2] = 0; + value[3] = 0; + + if (count==128) + count = get16(s); + else + count -= 127; + if (count > left) + return epuc("bad file","scanline overrun"); + + if (!pic_readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return epuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static stbi_uc *pic_load(stbi *s,int *px,int *py,int *comp,int req_comp) +{ + stbi_uc *result; + int i, x,y; + + for (i=0; i<92; ++i) + get8(s); + + x = get16(s); + y = get16(s); + if (at_eof(s)) return epuc("bad file","file too short (pic header)"); + if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode"); + + get32(s); //skip `ratio' + get16(s); //skip `fields' + get16(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) malloc(x*y*4); + memset(result, 0xff, x*y*4); + + if (!pic_load2(s,x,y,comp, result)) { + free(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi_pic_test(stbi *s) +{ + int r = pic_test(s); + stbi_rewind(s); + return r; +} + +static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + return pic_load(s,x,y,comp,req_comp); +} + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb +typedef struct stbi_gif_lzw_struct { + stbi_int16 prefix; + stbi_uint8 first; + stbi_uint8 suffix; +} stbi_gif_lzw; + +typedef struct stbi_gif_struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + int flags, bgindex, ratio, transparent, eflags; + stbi_uint8 pal[256][4]; + stbi_uint8 lpal[256][4]; + stbi_gif_lzw codes[4096]; + stbi_uint8 *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; +} stbi_gif; + +static int gif_test(stbi *s) +{ + int sz; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return 0; + sz = get8(s); + if (sz != '9' && sz != '7') return 0; + if (get8(s) != 'a') return 0; + return 1; +} + +static int stbi_gif_test(stbi *s) +{ + int r = gif_test(s); + stbi_rewind(s); + return r; +} + +static void stbi_gif_parse_colortable(stbi *s, stbi_uint8 pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + pal[i][3] = transp ? 0 : 255; + } +} + +static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info) +{ + stbi_uint8 version; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') + return e("not GIF", "Corrupt GIF"); + + version = get8u(s); + if (version != '7' && version != '9') return e("not GIF", "Corrupt GIF"); + if (get8(s) != 'a') return e("not GIF", "Corrupt GIF"); + + failure_reason = ""; + g->w = get16le(s); + g->h = get16le(s); + g->flags = get8(s); + g->bgindex = get8(s); + g->ratio = get8(s); + g->transparent = -1; + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi_gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp) +{ + stbi_gif g; + if (!stbi_gif_header(s, &g, comp, 1)) { + stbi_rewind( s ); + return 0; + } + if (x) *x = g.w; + if (y) *y = g.h; + return 1; +} + +static void stbi_out_gif_code(stbi_gif *g, stbi_uint16 code) +{ + stbi_uint8 *p, *c; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi_out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + p = &g->out[g->cur_x + g->cur_y]; + c = &g->color_table[g->codes[code].suffix * 4]; + + if (c[3] >= 128) { + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) +{ + stbi_uint8 lzw_cs; + stbi_int32 len, code; + stbi_uint32 first; + stbi_int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi_gif_lzw *p; + + lzw_cs = get8u(s); + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (code = 0; code < clear; code++) { + g->codes[code].prefix = -1; + g->codes[code].first = (stbi_uint8) code; + g->codes[code].suffix = (stbi_uint8) code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi_int32) get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi_int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + skip(s, len); + while ((len = get8(s)) > 0) + skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) return epuc("no clear code", "Corrupt GIF"); + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 4096) return epuc("too many codes", "Corrupt GIF"); + p->prefix = (stbi_int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return epuc("illegal code in raster", "Corrupt GIF"); + + stbi_out_gif_code(g, (stbi_uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return epuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +static void stbi_fill_gif_background(stbi_gif *g) +{ + int i; + stbi_uint8 *c = g->pal[g->bgindex]; + // @OPTIMIZE: write a dword at a time + for (i = 0; i < g->w * g->h * 4; i += 4) { + stbi_uint8 *p = &g->out[i]; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +static stbi_uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) +{ + int i; + stbi_uint8 *old_out = 0; + + if (g->out == 0) { + if (!stbi_gif_header(s, g, comp,0)) return 0; // failure_reason set by stbi_gif_header + g->out = (stbi_uint8 *) malloc(4 * g->w * g->h); + if (g->out == 0) return epuc("outofmem", "Out of memory"); + stbi_fill_gif_background(g); + } else { + // animated-gif-only path + if (((g->eflags & 0x1C) >> 2) == 3) { + old_out = g->out; + g->out = (stbi_uint8 *) malloc(4 * g->w * g->h); + if (g->out == 0) return epuc("outofmem", "Out of memory"); + memcpy(g->out, old_out, g->w*g->h*4); + } + } + + for (;;) { + switch (get8(s)) { + case 0x2C: /* Image Descriptor */ + { + stbi_int32 x, y, w, h; + stbi_uint8 *o; + + x = get16le(s); + y = get16le(s); + w = get16le(s); + h = get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return epuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + g->lflags = get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uint8 *) g->lpal; + } else if (g->flags & 0x80) { + for (i=0; i < 256; ++i) // @OPTIMIZE: reset only the previous transparent + g->pal[i][3] = 255; + if (g->transparent >= 0 && (g->eflags & 0x01)) + g->pal[g->transparent][3] = 0; + g->color_table = (stbi_uint8 *) g->pal; + } else + return epuc("missing color table", "Corrupt GIF"); + + o = stbi_process_gif_raster(s, g); + if (o == NULL) return NULL; + + if (req_comp && req_comp != 4) + o = convert_format(o, 4, req_comp, g->w, g->h); + return o; + } + + case 0x21: // Comment Extension. + { + int len; + if (get8(s) == 0xF9) { // Graphic Control Extension. + len = get8(s); + if (len == 4) { + g->eflags = get8(s); + get16le(s); // delay + g->transparent = get8(s); + } else { + skip(s, len); + break; + } + } + while ((len = get8(s)) != 0) + skip(s, len); + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uint8 *) 1; + + default: + return epuc("unknown code", "Corrupt GIF"); + } + } +} + +static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uint8 *u = 0; + stbi_gif g={0}; + + u = stbi_gif_load_next(s, &g, comp, req_comp); + if (u == (void *) 1) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + } + + return u; +} + +static int stbi_gif_info(stbi *s, int *x, int *y, int *comp) +{ + return stbi_gif_info_raw(s,x,y,comp); +} + + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int hdr_test(stbi *s) +{ + const char *signature = "#?RADIANCE\n"; + int i; + for (i=0; signature[i]; ++i) + if (get8(s) != signature[i]) + return 0; + return 1; +} + +static int stbi_hdr_test(stbi* s) +{ + int r = hdr_test(s); + stbi_rewind(s); + return r; +} + +#define HDR_BUFLEN 1024 +static char *hdr_gettoken(stbi *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) get8(z); + + while (!at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == HDR_BUFLEN-1) { + // flush to end of line + while (!at_eof(z) && get8(z) != '\n') + ; + break; + } + c = (char) get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + char buffer[HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + + + // Check identifier + if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) + return epf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return epf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = strtol(token, NULL, 10); + + *x = width; + *y = height; + + *comp = 3; + if (req_comp == 0) req_comp = 3; + + // Read data + hdr_data = (float *) malloc(height * width * req_comp * sizeof(float)); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + getn(s, rgbe, 4); + hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = get8(s); + c2 = get8(s); + len = get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uint8 rgbe[4]; + rgbe[0] = (stbi_uint8) c1; + rgbe[1] = (stbi_uint8) c2; + rgbe[2] = (stbi_uint8) len; + rgbe[3] = (stbi_uint8) get8u(s); + hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + free(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= get8(s); + if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4); + + for (k = 0; k < 4; ++k) { + i = 0; + while (i < width) { + count = get8u(s); + if (count > 128) { + // Run + value = get8u(s); + count -= 128; + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = get8u(s); + } + } + } + for (i=0; i < width; ++i) + hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + free(scanline); + } + + return hdr_data; +} + +static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + return hdr_load(s,x,y,comp,req_comp); +} + +static int stbi_hdr_info(stbi *s, int *x, int *y, int *comp) +{ + char buffer[HDR_BUFLEN]; + char *token; + int valid = 0; + + if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) { + stbi_rewind( s ); + return 0; + } + + for(;;) { + token = hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi_rewind( s ); + return 0; + } + token = hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi_rewind( s ); + return 0; + } + token += 3; + *y = strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi_rewind( s ); + return 0; + } + token += 3; + *x = strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +static int stbi_bmp_info(stbi *s, int *x, int *y, int *comp) +{ + int hsz; + if (get8(s) != 'B' || get8(s) != 'M') { + stbi_rewind( s ); + return 0; + } + skip(s,12); + hsz = get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) { + stbi_rewind( s ); + return 0; + } + if (hsz == 12) { + *x = get16le(s); + *y = get16le(s); + } else { + *x = get32le(s); + *y = get32le(s); + } + if (get16le(s) != 1) { + stbi_rewind( s ); + return 0; + } + *comp = get16le(s) / 8; + return 1; +} + +static int stbi_psd_info(stbi *s, int *x, int *y, int *comp) +{ + int channelCount; + if (get32(s) != 0x38425053) { + stbi_rewind( s ); + return 0; + } + if (get16(s) != 1) { + stbi_rewind( s ); + return 0; + } + skip(s, 6); + channelCount = get16(s); + if (channelCount < 0 || channelCount > 16) { + stbi_rewind( s ); + return 0; + } + *y = get32(s); + *x = get32(s); + if (get16(s) != 8) { + stbi_rewind( s ); + return 0; + } + if (get16(s) != 3) { + stbi_rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi_pic_info(stbi *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained; + pic_packet_t packets[10]; + + skip(s, 92); + + *x = get16(s); + *y = get16(s); + if (at_eof(s)) return 0; + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi_rewind( s ); + return 0; + } + + skip(s, 8); + + do { + pic_packet_t *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = get8(s); + packet->size = get8u(s); + packet->type = get8u(s); + packet->channel = get8u(s); + act_comp |= packet->channel; + + if (at_eof(s)) { + stbi_rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi_rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} + +static int stbi_info_main(stbi *s, int *x, int *y, int *comp) +{ + if (stbi_jpeg_info(s, x, y, comp)) + return 1; + if (stbi_png_info(s, x, y, comp)) + return 1; + if (stbi_gif_info(s, x, y, comp)) + return 1; + if (stbi_bmp_info(s, x, y, comp)) + return 1; + if (stbi_psd_info(s, x, y, comp)) + return 1; + if (stbi_pic_info(s, x, y, comp)) + return 1; + #ifndef STBI_NO_HDR + if (stbi_hdr_info(s, x, y, comp)) + return 1; + #endif + // test tga last because it's a crappy test! + if (stbi_tga_info(s, x, y, comp)) + return 1; + return e("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = fopen(filename, "rb"); + int result; + if (!f) return e("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi s; + long pos = ftell(f); + start_file(&s, f); + r = stbi_info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi s; + start_mem(&s,buffer,len); + return stbi_info_main(&s,x,y,comp); +} + +int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi_info_main(&s,x,y,comp); +} + +#endif // STBI_HEADER_FILE_ONLY + +/* + revision history: + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-uint8 to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva) + 1.21 fix use of 'uint8' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 2008-08-02 + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 first released version +*/ diff --git a/lib/stb/stb_image.h b/lib/stb/stb_image.h new file mode 100644 index 0000000..a4fdbd0 --- /dev/null +++ b/lib/stb/stb_image.h @@ -0,0 +1,7 @@ +#ifndef STB_IMAGE_H +#define STB_IMAGE_H + +#define STBI_HEADER_FILE_ONLY +#include "stb_image.c" + +#endif diff --git a/lib/stb/stb_truetype.c b/lib/stb/stb_truetype.c new file mode 100644 index 0000000..dc22d88 --- /dev/null +++ b/lib/stb/stb_truetype.c @@ -0,0 +1,2 @@ +#define STB_TRUETYPE_IMPLEMENTATION +#include "stb_truetype.h" diff --git a/lib/stb/stb_truetype.h b/lib/stb/stb_truetype.h new file mode 100644 index 0000000..37233cd --- /dev/null +++ b/lib/stb/stb_truetype.h @@ -0,0 +1,1960 @@ +// stb_truetype.h - v0.5 - public domain - 2009 Sean Barrett / RAD Game Tools +// +// This library processes TrueType files: +// parse files +// extract glyph metrics +// extract glyph shapes +// render glyphs to one-channel bitmaps with antialiasing (box filter) +// +// Todo: +// non-MS cmaps +// crashproof on bad data +// hinting? (no longer patented) +// cleartype-style AA? +// optimize: use simple memory allocator for intermediates +// optimize: build edge-list directly from curves +// optimize: rasterize directly from curves? +// +// ADDITIONAL CONTRIBUTORS +// +// Mikko Mononen: compound shape support, more cmap formats +// Tor Andersson: kerning, subpixel rendering +// +// Bug/warning reports: +// "Zer" on mollyrocket (with fix) +// Cass Everitt +// stoiko (Haemimont Games) +// Brian Hook +// Walter van Niftrik +// +// VERSION HISTORY +// +// 0.5 (2011-12-09) bugfixes: +// subpixel glyph renderer computed wrong bounding box +// first vertex of shape can be off-curve (FreeSans) +// 0.4b(2011-12-03) fixed an error in the font baking example +// 0.4 (2011-12-01) kerning, subpixel rendering (tor) +// bugfixes for: +// codepoint-to-glyph conversion using table fmt=12 +// codepoint-to-glyph conversion using table fmt=4 +// stbtt_GetBakedQuad with non-square texture (Zer) +// updated Hello World! sample to use kerning and subpixel +// fixed some warnings +// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) +// userdata, malloc-from-userdata, non-zero fill (STB) +// 0.2 (2009-03-11) Fix unsigned/signed char warnings +// 0.1 (2009-03-09) First public release +// +// USAGE +// +// Include this file in whatever places neeed to refer to it. In ONE C/C++ +// file, write: +// #define STB_TRUETYPE_IMPLEMENTATION +// before the #include of this file. This expands out the actual +// implementation into that C/C++ file. +// +// Look at the header-file sections below for the API, but here's a quick skim: +// +// Simple 3D API (don't ship this, but it's fine for tools and quick start, +// and you can cut and paste from it to move to more advanced) +// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture +// stbtt_GetBakedQuad() -- compute quad to draw for a given char +// +// "Load" a font file from a memory buffer (you have to keep the buffer loaded) +// stbtt_InitFont() +// stbtt_GetFontOffsetForIndex() -- use for TTC font collections +// +// Render a unicode codepoint to a bitmap +// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap +// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide +// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be +// +// Character advance/positioning +// stbtt_GetCodepointHMetrics() +// stbtt_GetFontVMetrics() +// stbtt_GetCodepointKernAdvance() +// +// ADVANCED USAGE +// +// Quality: +// +// - Use the functions with Subpixel at the end to allow your characters +// to have subpixel positioning. Since the font is anti-aliased, not +// hinted, this is very import for quality. +// +// - Kerning is now supported, and if you're supporting subpixel rendering +// then kerning is worth using to give your text a polished look. +// +// Performance: +// +// - Convert Unicode codepoints to "glyphs" and operate on the glyphs; if +// you don't do this, stb_truetype is forced to do the conversion on +// every call. +// +// - There are a lot of memory allocations. We should modify it to take +// a temp buffer and allocate from the temp buffer (without freeing), +// should help performance a lot. +// +// NOTES +// +// The system uses the raw data found in the .ttf file without changing it +// and without building auxiliary data structures. This is a bit inefficient +// on little-endian systems (the data is big-endian), but assuming you're +// caching the bitmaps or glyph shapes this shouldn't be a big deal. +// +// It appears to be very hard to programmatically determine what font a +// given file is in a general way. I provide an API for this, but I don't +// recommend it. +// +// +// SOURCE STATISTICS (based on v0.5, 1980 LOC) +// +// Documentation & header file 450 LOC \___ 550 LOC documentation +// Sample code 140 LOC / +// Truetype parsing 590 LOC ---- 600 LOC TrueType +// Software rasterization 240 LOC \ . +// Curve tesselation 120 LOC \__ 550 LOC Bitmap creation +// Bitmap management 100 LOC / +// Baked bitmap interface 70 LOC / +// Font name matching & access 150 LOC ---- 150 +// C runtime library abstraction 60 LOC ---- 60 + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// SAMPLE PROGRAMS +//// +// +// Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless +// +#if 0 +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<20]; +unsigned char temp_bitmap[512*512]; + +stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs +GLstbtt_uint ftex; + +void my_stbtt_initfont(void) +{ + fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb")); + stbtt_BakeFontBitmap(data,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits! + // can free ttf_buffer at this point + glGenTextures(1, &ftex); + glBindTexture(GL_TEXTURE_2D, ftex); + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap); + // can free temp_bitmap at this point + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); +} + +void my_stbtt_print(float x, float y, char *text) +{ + // assume orthographic projection with units = screen pixels, origin at top left + glBindTexture(GL_TEXTURE_2D, ftex); + glBegin(GL_QUADS); + while (*text) { + if (*text >= 32 && *text < 128) { + stbtt_aligned_quad q; + stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl,0=old d3d + glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1); + } + ++text; + } + glEnd(); +} +#endif +// +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program (this compiles): get a single bitmap, print as ASCII art +// +#if 0 +#include +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<25]; + +int main(int argc, char **argv) +{ + stbtt_fontinfo font; + unsigned char *bitmap; + int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); + + fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); + + stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); + bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); + + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) + putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); + putchar('\n'); + } + return 0; +} +#endif +// +// Output: +// +// .ii. +// @@@@@@. +// V@Mio@@o +// :i. V@V +// :oM@@M +// :@@@MM@M +// @@o o@M +// :@@. M@M +// @@@o@@@@ +// :M@@V:@@. +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program: print "Hello World!" banner, with bugs +// +#if 0 +char buffer[24<<20]; +unsigned char screen[20][79]; + +int main(int arg, char **argv) +{ + stbtt_fontinfo font; + int i,j,ascent,baseline,ch=0; + float scale, xpos=0; + char *text = "Heljo World!"; + + fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); + stbtt_InitFont(&font, buffer, 0); + + scale = stbtt_ScaleForPixelHeight(&font, 15); + stbtt_GetFontVMetrics(&font, &ascent,0,0); + baseline = (int) (ascent*scale); + + while (text[ch]) { + int advance,lsb,x0,y0,x1,y1; + float x_shift = xpos - (float) floor(xpos); + stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); + stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); + stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); + // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong + // because this API is really for baking character bitmaps into textures. if you want to do this, + // you need to render the bitmap to a temp buffer, then "alpha blend" that into the working buffer + xpos += (advance * scale); + if (text[ch+1]) + xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); + ++ch; + } + + for (j=0; j < 20; ++j) { + for (i=0; i < 78; ++i) + putchar(" .:ioVM@"[screen[j][i]>>5]); + putchar('\n'); + } + + return 0; +} +#endif + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// INTEGRATION WITH RUNTIME LIBRARIES +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + // #define your own (u)stbtt_int8/16/32 before including to override this + #ifndef stbtt_uint8 + typedef unsigned char stbtt_uint8; + typedef signed char stbtt_int8; + typedef unsigned short stbtt_uint16; + typedef signed short stbtt_int16; + typedef unsigned int stbtt_uint32; + typedef signed int stbtt_int32; + #endif + + typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; + typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; + + // #define your own STBTT_sort() to override this to avoid qsort + #ifndef STBTT_sort + #include + #define STBTT_sort(data,num_items,item_size,compare_func) qsort(data,num_items,item_size,compare_func) + #endif + + // #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h + #ifndef STBTT_ifloor + #include + #define STBTT_ifloor(x) ((int) floor(x)) + #define STBTT_iceil(x) ((int) ceil(x)) + #endif + + // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h + #ifndef STBTT_malloc + #ifndef __APPLE__ + #include + #endif + #define STBTT_malloc(x,u) malloc(x) + #define STBTT_free(x,u) free(x) + #endif + + #ifndef STBTT_assert + #include + #define STBTT_assert(x) assert(x) + #endif + + #ifndef STBTT_strlen + #include + #define STBTT_strlen(x) strlen(x) + #endif + + #ifndef STBTT_memcpy + #include + #define STBTT_memcpy memcpy + #define STBTT_memset memset + #endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// INTERFACE +//// +//// + +#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ +#define __STB_INCLUDE_STB_TRUETYPE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// TEXTURE BAKING API +// +// If you use this API, you only have to call two functions ever. +// + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; +} stbtt_bakedchar; + +extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata); // you allocate this, it's num_chars long +// if return is positive, the first unused row of the bitmap +// if return is negative, returns the negative of the number of characters that fit +// if return is 0, no characters fit and no rows were used +// This uses a very crappy packing. + +typedef struct +{ + float x0,y0,s0,t0; // top-left + float x1,y1,s1,t1; // bottom-right +} stbtt_aligned_quad; + +extern void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier +// Call GetBakedQuad with char_index = 'character - first_char', and it +// creates the quad you need to draw and advances the current position. +// It's inefficient; you might want to c&p it and optimize it. + + +////////////////////////////////////////////////////////////////////////////// +// +// FONT LOADING +// +// + +extern int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); +// Each .ttf file may have more than one font. Each has a sequential index +// number starting from 0. Call this function to get the font offset for a +// given index; it returns -1 if the index is out of range. A regular .ttf +// file will only define one font and it always be at offset 0, so it will +// return '0' for index 0, and -1 for all other indices. You can just skip +// this step if you know it's that kind of font. + + +// The following structure is defined publically so you can declare one on +// the stack or as a global or etc. +typedef struct +{ + void * userdata; + unsigned char * data; // pointer to .ttf file + int fontstart; // offset of start of font + + int numGlyphs; // number of glyphs, needed for range checking + + int loca,head,glyf,hhea,hmtx,kern; // table locations as offset from start of .ttf + int index_map; // a cmap mapping for our chosen character encoding + int indexToLocFormat; // format needed to map from glyph index to glyph +} stbtt_fontinfo; + +extern int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); +// Given an offset into the file that defines a font, this function builds +// the necessary cached info for the rest of the system. You must allocate +// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't +// need to do anything special to free it, because the contents are a pure +// cache with no additional data structures. Returns 0 on failure. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER TO GLYPH-INDEX CONVERSIOn + +int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); +// If you're going to perform multiple operations on the same character +// and you want a speed-up, call this function with the character you're +// going to process, then use glyph-based functions instead of the +// codepoint-based functions. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER PROPERTIES +// + +extern float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose "height" is 'pixels' tall. +// Height is measured as the distance from the highest ascender to the lowest +// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics +// and computing: +// scale = pixels / (ascent - descent) +// so if you prefer to measure height by the ascent only, use a similar calculation. + +extern void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); +// ascent is the coordinate above the baseline the font extends; descent +// is the coordinate below the baseline the font extends (i.e. it is typically negative) +// lineGap is the spacing between one row's descent and the next row's ascent... +// so you should advance the vertical position by "*ascent - *descent + *lineGap" +// these are expressed in unscaled coordinates + +extern void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); +// leftSideBearing is the offset from the current horizontal position to the left edge of the character +// advanceWidth is the offset from the current horizontal position to the next horizontal position +// these are expressed in unscaled coordinates + +extern int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); +// an additional amount to add to the 'advance' value between ch1 and ch2 +// @TODO; for now always returns 0! + +extern int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); +// Gets the bounding box of the visible part of the glyph, in unscaled coordinates + +extern void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); +extern int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); +extern int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); +// as above, but takes one or more glyph indices for greater efficiency + + +////////////////////////////////////////////////////////////////////////////// +// +// GLYPH SHAPES (you probably don't need these, but they have to go before +// the bitmaps for C declaration-order reasons) +// + +#ifndef STBTT_vmove // you can predefine these to use different values (but why?) + enum { + STBTT_vmove=1, + STBTT_vline, + STBTT_vcurve + }; +#endif + +#ifndef stbtt_vertex // you can predefine this to use different values + // (we share this with other code at RAD) + #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file + typedef struct + { + stbtt_vertex_type x,y,cx,cy; + unsigned char type,padding; + } stbtt_vertex; +#endif + +extern int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); +extern int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); +// returns # of vertices and fills *vertices with the pointer to them +// these are expressed in "unscaled" coordinates + +extern void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); +// frees the data allocated above + +////////////////////////////////////////////////////////////////////////////// +// +// BITMAP RENDERING +// + +extern void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); +// frees the bitmap allocated below + +extern unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// allocates a large-enough single-channel 8bpp bitmap and renders the +// specified character/glyph at the specified scale into it, with +// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). +// *width & *height are filled out with the width & height of the bitmap, +// which is stored left-to-right, top-to-bottom. +// +// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap + +extern unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel +// shift for the character + +extern void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); +// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap +// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap +// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the +// width and height and positioning info for it first. + +extern void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint); +// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel +// shift for the character + +extern void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +// get the bbox of the bitmap centered around the glyph origin; so the +// bitmap width is ix1-ix0, height is iy1-iy0, and location to place +// the bitmap top left is (leftSideBearing*scale,iy0). +// (Note that the bitmap uses y-increases-down, but the shape uses +// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) + +extern void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); +// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel +// shift for the character + +// the following functions are equivalent to the above functions, but operate +// on glyph indices instead of Unicode codepoints (for efficiency) +extern unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +extern unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); +extern void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); +extern void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); +extern void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +extern void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); + + +// @TODO: don't expose this structure +typedef struct +{ + int w,h,stride; + unsigned char *pixels; +} stbtt__bitmap; + +extern void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata); + +////////////////////////////////////////////////////////////////////////////// +// +// Finding the right font... +// +// You should really just solve this offline, keep your own tables +// of what font is what, and don't try to get it out of the .ttf file. +// That's because getting it out of the .ttf file is really hard, because +// the names in the file can appear in many possible encodings, in many +// possible languages, and e.g. if you need a case-insensitive comparison, +// the details of that depend on the encoding & language in a complex way +// (actually underspecified in truetype, but also gigantic). +// +// But you can use the provided functions in two possible ways: +// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on +// unicode-encoded names to try to find the font you want; +// you can run this before calling stbtt_InitFont() +// +// stbtt_GetFontNameString() lets you get any of the various strings +// from the file yourself and do your own comparisons on them. +// You have to have called stbtt_InitFont() first. + + +extern int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); +// returns the offset (not index) of the font that matches, or -1 if none +// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". +// if you use any other flag, use a font name like "Arial"; this checks +// the 'macStyle' header field; i don't know if fonts set this consistently +#define STBTT_MACSTYLE_DONTCARE 0 +#define STBTT_MACSTYLE_BOLD 1 +#define STBTT_MACSTYLE_ITALIC 2 +#define STBTT_MACSTYLE_UNDERSCORE 4 +#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 + +extern int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); +// returns 1/0 whether the first string interpreted as utf8 is identical to +// the second string interpreted as big-endian utf16... useful for strings from next func + +extern const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); +// returns the string (which may be big-endian double byte, e.g. for unicode) +// and puts the length in bytes in *length. +// +// some of the values for the IDs are below; for more see the truetype spec: +// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html +// http://www.microsoft.com/typography/otspec/name.htm + +enum { // platformID + STBTT_PLATFORM_ID_UNICODE =0, + STBTT_PLATFORM_ID_MAC =1, + STBTT_PLATFORM_ID_ISO =2, + STBTT_PLATFORM_ID_MICROSOFT =3 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_UNICODE + STBTT_UNICODE_EID_UNICODE_1_0 =0, + STBTT_UNICODE_EID_UNICODE_1_1 =1, + STBTT_UNICODE_EID_ISO_10646 =2, + STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, + STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT + STBTT_MS_EID_SYMBOL =0, + STBTT_MS_EID_UNICODE_BMP =1, + STBTT_MS_EID_SHIFTJIS =2, + STBTT_MS_EID_UNICODE_FULL =10 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes + STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, + STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, + STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, + STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 +}; + +enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... + // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs + STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, + STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, + STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, + STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, + STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, + STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D +}; + +enum { // languageID for STBTT_PLATFORM_ID_MAC + STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, + STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, + STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, + STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , + STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , + STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, + STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 +}; + +#ifdef __cplusplus +} +#endif + +#endif // __STB_INCLUDE_STB_TRUETYPE_H__ + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// IMPLEMENTATION +//// +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + +////////////////////////////////////////////////////////////////////////// +// +// accessors to parse data from file +// + +// on platforms that don't allow misaligned reads, if we want to allow +// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE + +#define ttBYTE(p) (* (stbtt_uint8 *) (p)) +#define ttCHAR(p) (* (stbtt_int8 *) (p)) +#define ttFixed(p) ttLONG(p) + +#if defined(STB_TRUETYPE_BIGENDIAN) && !defined(ALLOW_UNALIGNED_TRUETYPE) + + #define ttUSHORT(p) (* (stbtt_uint16 *) (p)) + #define ttSHORT(p) (* (stbtt_int16 *) (p)) + #define ttULONG(p) (* (stbtt_uint32 *) (p)) + #define ttLONG(p) (* (stbtt_int32 *) (p)) + +#else + + stbtt_uint16 ttUSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; } + stbtt_int16 ttSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; } + stbtt_uint32 ttULONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + stbtt_int32 ttLONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + +#endif + +#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) +#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) + +static int stbtt__isfont(const stbtt_uint8 *font) +{ + // check the version number + if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 + if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! + if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF + if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 + return 0; +} + +// @OPTIMIZE: binary search +static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) +{ + stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); + stbtt_uint32 tabledir = fontstart + 12; + stbtt_int32 i; + for (i=0; i < num_tables; ++i) { + stbtt_uint32 loc = tabledir + 16*i; + if (stbtt_tag(data+loc+0, tag)) + return ttULONG(data+loc+8); + } + return 0; +} + +int stbtt_GetFontOffsetForIndex(const unsigned char *font_collection, int index) +{ + // if it's just a font, there's only one valid index + if (stbtt__isfont(font_collection)) + return index == 0 ? 0 : -1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + stbtt_int32 n = ttLONG(font_collection+8); + if (index >= n) + return -1; + return ttULONG(font_collection+12+index*14); + } + } + return -1; +} + +int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data2, int fontstart) +{ + stbtt_uint8 *data = (stbtt_uint8 *) data2; + stbtt_uint32 cmap, t; + stbtt_int32 i,numTables; + + info->data = data; + info->fontstart = fontstart; + + cmap = stbtt__find_table(data, fontstart, "cmap"); // required + info->loca = stbtt__find_table(data, fontstart, "loca"); // required + info->head = stbtt__find_table(data, fontstart, "head"); // required + info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required + info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required + info->kern = stbtt__find_table(data, fontstart, "kern"); // not required + if (!cmap || !info->loca || !info->head || !info->glyf || !info->hhea || !info->hmtx) + return 0; + + t = stbtt__find_table(data, fontstart, "maxp"); + if (t) + info->numGlyphs = ttUSHORT(data+t+4); + else + info->numGlyphs = 0xffff; + + // find a cmap encoding table we understand *now* to avoid searching + // later. (todo: could make this installable) + // the same regardless of glyph. + numTables = ttUSHORT(data + cmap + 2); + info->index_map = 0; + for (i=0; i < numTables; ++i) { + stbtt_uint32 encoding_record = cmap + 4 + 8 * i; + // find an encoding we understand: + switch(ttUSHORT(data+encoding_record)) { + case STBTT_PLATFORM_ID_MICROSOFT: + switch (ttUSHORT(data+encoding_record+2)) { + case STBTT_MS_EID_UNICODE_BMP: + case STBTT_MS_EID_UNICODE_FULL: + // MS/Unicode + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + break; + } + } + if (info->index_map == 0) + return 0; + + info->indexToLocFormat = ttUSHORT(data+info->head + 50); + return 1; +} + +int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) +{ + stbtt_uint8 *data = info->data; + stbtt_uint32 index_map = info->index_map; + + stbtt_uint16 format = ttUSHORT(data + index_map + 0); + if (format == 0) { // apple byte encoding + stbtt_int32 bytes = ttUSHORT(data + index_map + 2); + if (unicode_codepoint < bytes-6) + return ttBYTE(data + index_map + 6 + unicode_codepoint); + return 0; + } else if (format == 6) { + stbtt_uint32 first = ttUSHORT(data + index_map + 6); + stbtt_uint32 count = ttUSHORT(data + index_map + 8); + if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) + return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); + return 0; + } else if (format == 2) { + STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean + return 0; + } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges + stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; + stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; + stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); + stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; + stbtt_uint16 item, offset, start/*, end*/; + + // do a binary search of the segments + stbtt_uint32 endCount = index_map + 14; + stbtt_uint32 search = endCount; + + if (unicode_codepoint > 0xffff) + return 0; + + // they lie from endCount .. endCount + segCount + // but searchRange is the nearest power of two, so... + if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) + search += rangeShift*2; + + // now decrement to bias correctly to find smallest + search -= 2; + while (entrySelector) { + stbtt_uint16 /*start,*/ end; + searchRange >>= 1; + //start = ttUSHORT(data + search + 2 + segcount*2 + 2); + end = ttUSHORT(data + search + 2); + //start = ttUSHORT(data + search + searchRange*2 + segcount*2 + 2); + end = ttUSHORT(data + search + searchRange*2); + if (unicode_codepoint > end) + search += searchRange*2; + --entrySelector; + } + search += 2; + + item = (stbtt_uint16) ((search - endCount) >> 1); + + STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item)); + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + //end = ttUSHORT(data + index_map + 14 + 2 + 2*item); + if (unicode_codepoint < start) + return 0; + + offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); + if (offset == 0) + return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); + + return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); + } else if (format == 12 || format == 13) { + stbtt_uint32 ngroups = ttULONG(data+index_map+12); + stbtt_int32 low,high; + //stbtt_uint16 g = 0; + low = 0; high = (stbtt_int32)ngroups; + // Binary search the right group. + while (low < high) { + stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high + stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); + stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); + if ((stbtt_uint32) unicode_codepoint < start_char) + high = mid; + else if ((stbtt_uint32) unicode_codepoint > end_char) + low = mid+1; + else { + stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); + if (format == 12) + return start_glyph + unicode_codepoint-start_char; + else // format == 13 + return start_glyph; + } + } + return 0; // not found + } + // @TODO + STBTT_assert(0); + return 0; +} + +int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) +{ + return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); +} + +static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int16 x, stbtt_int16 y, stbtt_int16 cx, stbtt_int16 cy) +{ + v->type = type; + v->x = x; + v->y = y; + v->cx = cx; + v->cy = cy; +} + +static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) +{ + int g1,g2; + + if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range + if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format + + if (info->indexToLocFormat == 0) { + g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; + g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; + } else { + g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); + g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); + } + + return g1==g2 ? -1 : g1; // if length is 0, return -1 +} + +int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + int g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 0; + + if (x0) *x0 = ttSHORT(info->data + g + 2); + if (y0) *y0 = ttSHORT(info->data + g + 4); + if (x1) *x1 = ttSHORT(info->data + g + 6); + if (y1) *y1 = ttSHORT(info->data + g + 8); + return 1; +} + +int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) +{ + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, + stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) +{ + if (start_off) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + return num_vertices; +} + +int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + stbtt_int16 numberOfContours; + stbtt_uint8 *endPtsOfContours; + stbtt_uint8 *data = info->data; + stbtt_vertex *vertices=0; + int num_vertices=0; + int g = stbtt__GetGlyfOffset(info, glyph_index); + + *pvertices = NULL; + + if (g < 0) return 0; + + numberOfContours = ttSHORT(data + g); + + if (numberOfContours > 0) { + stbtt_uint8 flags=0,flagcount; + stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; //, curve_end=0; + stbtt_int32 x,y,cx,cy,sx,sy, scx=0,scy=0; + stbtt_uint8 *points; + endPtsOfContours = (data + g + 10); + ins = ttUSHORT(data + g + 10 + numberOfContours * 2); + points = data + g + 10 + numberOfContours * 2 + 2 + ins; + + n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); + + m = n + 2*numberOfContours; // a loose bound on how many vertices we might need + vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); + if (vertices == 0) + return 0; + + next_move = 0; + flagcount=0; + + // in first pass, we load uninterpreted data into the allocated array + // above, shifted to the end of the array so we won't overwrite it when + // we create our final data starting from the front + + off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated + + // first load flags + + for (i=0; i < n; ++i) { + if (flagcount == 0) { + flags = *points++; + if (flags & 8) + flagcount = *points++; + } else + --flagcount; + vertices[off+i].type = flags; + } + + // now load x coordinates + x=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 2) { + stbtt_int16 dx = *points++; + x += (flags & 16) ? dx : -dx; // ??? + } else { + if (!(flags & 16)) { + x = x + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].x = x; + } + + // now load y coordinates + y=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 4) { + stbtt_int16 dy = *points++; + y += (flags & 32) ? dy : -dy; // ??? + } else { + if (!(flags & 32)) { + y = y + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].y = y; + } + + // now convert them to our format + num_vertices=0; + sx = sy = cx = cy = 0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + x = (stbtt_int16) vertices[off+i].x; + y = (stbtt_int16) vertices[off+i].y; + + if (next_move == i) { + if (i != 0) + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + + // now start the new one + start_off = !(flags & 1); + if (start_off) { + // if we start off with an off-curve point, then when we need to find a point on the curve + // where we can start, and we need to save some state for when we wraparound. + scx = x; + scy = y; + if (!(vertices[off+i+1].type & 1)) { + // next point is also a curve point, so interpolate an on-point curve + sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; + sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; + } else { + // otherwise just use the next point as our start point + sx = (stbtt_int32) vertices[off+i+1].x; + sy = (stbtt_int32) vertices[off+i+1].y; + ++i; // we're using point i+1 as the starting point, so skip it + } + } else { + sx = x; + sy = y; + } + stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); + was_off = 0; + next_move = 1 + ttUSHORT(endPtsOfContours+j*2); + ++j; + } else { + if (!(flags & 1)) { // if it's a curve + if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); + cx = x; + cy = y; + was_off = 1; + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); + was_off = 0; + } + } + } + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + } else if (numberOfContours == -1) { + // Compound shapes. + int more = 1; + stbtt_uint8 *comp = data + g + 10; + num_vertices = 0; + vertices = 0; + while (more) { + stbtt_uint16 flags, gidx; + int comp_num_verts = 0, i; + stbtt_vertex *comp_verts = 0, *tmp = 0; + float mtx[6] = {1,0,0,1,0,0}, m, n; + + flags = ttSHORT(comp); comp+=2; + gidx = ttSHORT(comp); comp+=2; + + if (flags & 2) { // XY values + if (flags & 1) { // shorts + mtx[4] = ttSHORT(comp); comp+=2; + mtx[5] = ttSHORT(comp); comp+=2; + } else { + mtx[4] = ttCHAR(comp); comp+=1; + mtx[5] = ttCHAR(comp); comp+=1; + } + } + else { + // @TODO handle matching point + STBTT_assert(0); + } + if (flags & (1<<3)) { // WE_HAVE_A_SCALE + mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } + + // Find transformation scales. + m = (float) sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (float) sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); + + // Get indexed glyph. + comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); + if (comp_num_verts > 0) { + // Transform vertices. + for (i = 0; i < comp_num_verts; ++i) { + stbtt_vertex* v = &comp_verts[i]; + stbtt_vertex_type x,y; + x=v->x; y=v->y; + v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + x=v->cx; y=v->cy; + v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + } + // Append vertices. + tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); + if (!tmp) { + if (vertices) STBTT_free(vertices, info->userdata); + if (comp_verts) STBTT_free(comp_verts, info->userdata); + return 0; + } + if (num_vertices > 0) memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); + memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); + if (vertices) STBTT_free(vertices, info->userdata); + vertices = tmp; + STBTT_free(comp_verts, info->userdata); + num_vertices += comp_num_verts; + } + // More components ? + more = flags & (1<<5); + } + } else if (numberOfContours < 0) { + // @TODO other compound variations? + STBTT_assert(0); + } else { + // numberOfCounters == 0, do nothing + } + + *pvertices = vertices; + return num_vertices; +} + +void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) +{ + stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); + if (glyph_index < numOfLongHorMetrics) { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); + } else { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); + } +} + +int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + stbtt_uint8 *data = info->data + info->kern; + stbtt_uint32 needle, straw; + int l, r, m; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + l = 0; + r = ttUSHORT(data+10) - 1; + needle = glyph1 << 16 | glyph2; + while (l <= r) { + m = (l + r) >> 1; + straw = ttULONG(data+18+(m*6)); // note: unaligned read + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else + return ttSHORT(data+22+(m*6)); + } + return 0; +} + +int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) +{ + if (!info->kern) // if no kerning table, don't waste time looking up both codepoint->glyphs + return 0; + return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); +} + +void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) +{ + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); + if (descent) *descent = ttSHORT(info->data+info->hhea + 6); + if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); +} + +float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) +{ + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (float) height / fheight; +} + +void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + STBTT_free(v, info->userdata); +} + +////////////////////////////////////////////////////////////////////////////// +// +// antialiasing software rasterizer +// + +void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + int x0,y0,x1,y1; + if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) + x0=y0=x1=y1=0; // e.g. space character + // now move to integral bboxes (treating pixels as little squares, what pixels get touched)? + if (ix0) *ix0 = STBTT_ifloor(x0 * scale_x + shift_x); + if (iy0) *iy0 = -STBTT_iceil (y1 * scale_y + shift_y); + if (ix1) *ix1 = STBTT_iceil (x1 * scale_x + shift_x); + if (iy1) *iy1 = -STBTT_ifloor(y0 * scale_y + shift_y); +} +void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); +} + +void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); +} + +void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); +} + +typedef struct stbtt__edge { + float x0,y0, x1,y1; + int invert; +} stbtt__edge; + +typedef struct stbtt__active_edge +{ + int x,dx; + float ey; + struct stbtt__active_edge *next; + int valid; +} stbtt__active_edge; + +#define FIXSHIFT 10 +#define FIX (1 << FIXSHIFT) +#define FIXMASK (FIX-1) + +static stbtt__active_edge *new_active(stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) STBTT_malloc(sizeof(*z), userdata); // @TODO: make a pool of these!!! + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(e->y0 <= start_point); + if (!z) return z; + // round dx down to avoid going too far + if (dxdy < 0) + z->dx = -STBTT_ifloor(FIX * -dxdy); + else + z->dx = STBTT_ifloor(FIX * dxdy); + z->x = STBTT_ifloor(FIX * (e->x0 + dxdy * (start_point - e->y0))); + z->x -= off_x * FIX; + z->ey = e->y1; + z->next = 0; + z->valid = e->invert ? 1 : -1; + return z; +} + +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap +static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) +{ + // non-zero winding fill + int x0=0, w=0; + + while (e) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w += e->valid; + } else { + int x1 = e->x; w += e->valid; + // if we went to zero, we need to draw + if (w == 0) { + int i = x0 >> FIXSHIFT; + int j = x1 >> FIXSHIFT; + + if (i < len && j >= 0) { + if (i == j) { + // x0,x1 are the same pixel, so compute combined coverage + scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> FIXSHIFT); + } else { + if (i >= 0) // add antialiasing for x0 + scanline[i] = scanline[i] + (stbtt_uint8) (((FIX - (x0 & FIXMASK)) * max_weight) >> FIXSHIFT); + else + i = -1; // clip + + if (j < len) // add antialiasing for x1 + scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & FIXMASK) * max_weight) >> FIXSHIFT); + else + j = len; // clip + + for (++i; i < j; ++i) // fill pixels between x0 and x1 + scanline[i] = scanline[i] + (stbtt_uint8) max_weight; + } + } + } + } + + e = e->next; + } +} + +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__active_edge *active = NULL; + int y,j=0; + int max_weight = (255 / vsubsample); // weight per vertical scanline + int s; // vertical subsample index + unsigned char scanline_data[512], *scanline; + + if (result->w > 512) + scanline = (unsigned char *) STBTT_malloc(result->w, userdata); + else + scanline = scanline_data; + + y = off_y * vsubsample; + e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; + + while (j < result->h) { + STBTT_memset(scanline, 0, result->w); + for (s=0; s < vsubsample; ++s) { + // find center of pixel for this scanline + float scan_y = y + 0.5f; + stbtt__active_edge **step = &active; + + // update all active edges; + // remove all active edges that terminate before the center of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y) { + *step = z->next; // delete from list + STBTT_assert(z->valid); + z->valid = 0; + STBTT_free(z, userdata); + } else { + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + } + + // resort the list if needed + for(;;) { + int changed=0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + stbtt__active_edge *t = *step; + stbtt__active_edge *q = t->next; + + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline + while (e->y0 <= scan_y) { + if (e->y1 > scan_y) { + stbtt__active_edge *z = new_active(e, off_x, scan_y, userdata); + // find insertion point + if (active == NULL) + active = z; + else if (z->x < active->x) { + // insert at front + z->next = active; + active = z; + } else { + // find thing to insert AFTER + stbtt__active_edge *p = active; + while (p->next && p->next->x < z->x) + p = p->next; + // at this point, p->next->x is NOT < z->x + z->next = p->next; + p->next = z; + } + } + ++e; + } + + // now process all active edges in XOR fashion + if (active) + stbtt__fill_active_edges(scanline, result->w, active, max_weight); + + ++y; + } + STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); + ++j; + } + + while (active) { + stbtt__active_edge *z = active; + active = active->next; + STBTT_free(z, userdata); + } + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} + +static int stbtt__edge_compare(const void *p, const void *q) +{ + stbtt__edge *a = (stbtt__edge *) p; + stbtt__edge *b = (stbtt__edge *) q; + + if (a->y0 < b->y0) return -1; + if (a->y0 > b->y0) return 1; + return 0; +} + +typedef struct +{ + float x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) +{ + float y_scale_inv = invert ? -scale_y : scale_y; + stbtt__edge *e; + int n,i,j,k,m; + int vsubsample = result->h < 8 ? 15 : 5; + // vsubsample should divide 255 evenly; otherwise we won't reach full opacity + + // now we have to blow out the windings into explicit edge lists + n = 0; + for (i=0; i < windings; ++i) + n += wcount[i]; + + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel + if (e == 0) return; + n = 0; + + m=0; + for (i=0; i < windings; ++i) { + stbtt__point *p = pts + m; + m += wcount[i]; + j = wcount[i]-1; + for (k=0; k < wcount[i]; j=k++) { + int a=k,b=j; + // skip the edge if horizontal + if (p[j].y == p[k].y) + continue; + // add edge from j to k to the list + e[n].invert = 0; + if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { + e[n].invert = 1; + a=j,b=k; + } + e[n].x0 = p[a].x * scale_x + shift_x; + e[n].y0 = p[a].y * y_scale_inv * vsubsample + shift_y; + e[n].x1 = p[b].x * scale_x + shift_x; + e[n].y1 = p[b].y * y_scale_inv * vsubsample + shift_y; + ++n; + } + } + + // now sort the edges by their highest point (should snap to integer, and then by x) + STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); + + // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule + stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); + + STBTT_free(e, userdata); +} + +static void stbtt__add_point(stbtt__point *points, int n, float x, float y) +{ + if (!points) return; // during first pass, it's unallocated + points[n].x = x; + points[n].y = y; +} + +// tesselate until threshhold p is happy... @TODO warped to compensate for non-linear stretching +static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) +{ + // midpoint + float mx = (x0 + 2*x1 + x2)/4; + float my = (y0 + 2*y1 + y2)/4; + // versus directly drawn line + float dx = (x0+x2)/2 - mx; + float dy = (y0+y2)/2 - my; + if (n > 16) // 65536 segments on one curve better be enough! + return 1; + if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA + stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x2,y2); + *num_points = *num_points+1; + } + return 1; +} + +// returns number of contours +stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + stbtt__point *points=0; + int num_points=0; + + float objspace_flatness_squared = objspace_flatness * objspace_flatness; + int i,n=0,start=0, pass; + + // count how many "moves" there are to get the contour count + for (i=0; i < num_verts; ++i) + if (vertices[i].type == STBTT_vmove) + ++n; + + *num_contours = n; + if (n == 0) return 0; + + *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); + + if (*contour_lengths == 0) { + *num_contours = 0; + return 0; + } + + // make two passes through the points so we don't need to realloc + for (pass=0; pass < 2; ++pass) { + float x=0,y=0; + if (pass == 1) { + points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); + if (points == NULL) goto error; + } + num_points = 0; + n= -1; + for (i=0; i < num_verts; ++i) { + switch (vertices[i].type) { + case STBTT_vmove: + // start the next contour + if (n >= 0) + (*contour_lengths)[n] = num_points - start; + ++n; + start = num_points; + + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x,y); + break; + case STBTT_vline: + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x, y); + break; + case STBTT_vcurve: + stbtt__tesselate_curve(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + } + } + (*contour_lengths)[n] = num_points - start; + } + + return points; +error: + STBTT_free(points, userdata); + STBTT_free(*contour_lengths, userdata); + *contour_lengths = 0; + *num_contours = 0; + return NULL; +} + +void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) +{ + float scale = scale_x > scale_y ? scale_y : scale_x; + int winding_count, *winding_lengths; + stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); + if (windings) { + stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); + STBTT_free(winding_lengths, userdata); + STBTT_free(windings, userdata); + } +} + +void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + int ix0,iy0,ix1,iy1; + stbtt__bitmap gbm; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + + if (scale_x == 0) scale_x = scale_y; + if (scale_y == 0) { + if (scale_x == 0) return NULL; + scale_y = scale_x; + } + + stbtt_GetGlyphBitmapBox(info, glyph, scale_x, scale_y, &ix0,&iy0,&ix1,&iy1); + + // now we get the size + gbm.w = (ix1 - ix0); + gbm.h = (iy1 - iy0); + gbm.pixels = NULL; // in case we error + + if (width ) *width = gbm.w; + if (height) *height = gbm.h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + if (gbm.w && gbm.h) { + gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); + if (gbm.pixels) { + gbm.stride = gbm.w; + + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); + } + } + STBTT_free(vertices, info->userdata); + return gbm.pixels; +} + +unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); +} + +void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) +{ + int ix0,iy0; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + stbtt__bitmap gbm; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); + gbm.pixels = output; + gbm.w = out_w; + gbm.h = out_h; + gbm.stride = out_stride; + + if (gbm.w && gbm.h) + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); + + STBTT_free(vertices, info->userdata); +} + +void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); +} + +unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); +} + +void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); +} + +void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) +{ + stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); +} + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-CRAPPY packing to keep source code small + +extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata) +{ + float scale; + int x,y,bottom_y, i; + stbtt_fontinfo f; + stbtt_InitFont(&f, data, offset); + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + x=y=1; + bottom_y = 1; + + scale = stbtt_ScaleForPixelHeight(&f, pixel_height); + + for (i=0; i < num_chars; ++i) { + int advance, lsb, x0,y0,x1,y1,gw,gh; + int g = stbtt_FindGlyphIndex(&f, first_char + i); + stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); + stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); + gw = x1-x0; + gh = y1-y0; + if (x + gw + 1 >= pw) + y = bottom_y, x = 1; // advance to next row + if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row + return -i; + STBTT_assert(x+gw < pw); + STBTT_assert(y+gh < ph); + stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); + chardata[i].x0 = (stbtt_int16) x; + chardata[i].y0 = (stbtt_int16) y; + chardata[i].x1 = (stbtt_int16) (x + gw); + chardata[i].y1 = (stbtt_int16) (y + gh); + chardata[i].xadvance = scale * advance; + chardata[i].xoff = (float) x0; + chardata[i].yoff = (float) y0; + x = x + gw + 2; + if (y+gh+2 > bottom_y) + bottom_y = y+gh+2; + } + return bottom_y; +} + +void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + float d3d_bias = opengl_fillrule ? 0 : -0.5f; + float ipw = 1.0f / pw, iph = 1.0f / ph; + stbtt_bakedchar *b = chardata + char_index; + int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5); + int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5); + + q->x0 = round_x + d3d_bias; + q->y0 = round_y + d3d_bias; + q->x1 = round_x + b->x1 - b->x0 + d3d_bias; + q->y1 = round_y + b->y1 - b->y0 + d3d_bias; + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// font name matching -- recommended not to use this +// + +// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string +static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(const stbtt_uint8 *s1, stbtt_int32 len1, const stbtt_uint8 *s2, stbtt_int32 len2) +{ + stbtt_int32 i=0; + + // convert utf16 to utf8 and compare the results while converting + while (len2) { + stbtt_uint16 ch = s2[0]*256 + s2[1]; + if (ch < 0x80) { + if (i >= len1) return -1; + if (s1[i++] != ch) return -1; + } else if (ch < 0x800) { + if (i+1 >= len1) return -1; + if (s1[i++] != 0xc0 + (ch >> 6)) return -1; + if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; + } else if (ch >= 0xd800 && ch < 0xdc00) { + stbtt_uint32 c; + stbtt_uint16 ch2 = s2[2]*256 + s2[3]; + if (i+3 >= len1) return -1; + c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; + if (s1[i++] != 0xf0 + (c >> 18)) return -1; + if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; + s2 += 2; // plus another 2 below + len2 -= 2; + } else if (ch >= 0xdc00 && ch < 0xe000) { + return -1; + } else { + if (i+2 >= len1) return -1; + if (s1[i++] != 0xe0 + (ch >> 12)) return -1; + if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; + } + s2 += 2; + len2 -= 2; + } + return i; +} + +int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) +{ + return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((const stbtt_uint8*) s1, len1, (const stbtt_uint8*) s2, len2); +} + +// returns results in whatever encoding you request... but note that 2-byte encodings +// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare +const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) +{ + stbtt_int32 i,count,stringOffset; + stbtt_uint8 *fc = font->data; + stbtt_uint32 offset = font->fontstart; + stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return NULL; + + count = ttUSHORT(fc+nm+2); + stringOffset = nm + ttUSHORT(fc+nm+4); + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) + && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { + *length = ttUSHORT(fc+loc+8); + return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); + } + } + return NULL; +} + +static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) +{ + stbtt_int32 i; + stbtt_int32 count = ttUSHORT(fc+nm+2); + stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); + + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + stbtt_int32 id = ttUSHORT(fc+loc+6); + if (id == target_id) { + // find the encoding + stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); + + // is this a Unicode encoding? + if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { + stbtt_int32 slen = ttUSHORT(fc+loc+8), off = ttUSHORT(fc+loc+10); + + // check if there's a prefix match + stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); + if (matchlen >= 0) { + // check for target_id+1 immediately following, with same encoding & language + if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { + stbtt_int32 slen = ttUSHORT(fc+loc+12+8), off = ttUSHORT(fc+loc+12+10); + if (slen == 0) { + if (matchlen == nlen) + return 1; + } else if (matchlen < nlen && name[matchlen] == ' ') { + ++matchlen; + if (stbtt_CompareUTF8toUTF16_bigendian((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) + return 1; + } + } else { + // if nothing immediately following + if (matchlen == nlen) + return 1; + } + } + } + + // @TODO handle other encodings + } + } + return 0; +} + +static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) +{ + stbtt_int32 nlen = STBTT_strlen((char *) name); + stbtt_uint32 nm,hd; + if (!stbtt__isfont(fc+offset)) return 0; + + // check italics/bold/underline flags in macStyle... + if (flags) { + hd = stbtt__find_table(fc, offset, "head"); + if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; + } + + nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return 0; + + if (flags) { + // if we checked the macStyle flags, then just check the family and ignore the subfamily + if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } else { + if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } + + return 0; +} + +int stbtt_FindMatchingFont(const unsigned char *font_collection, const char *name_utf8, stbtt_int32 flags) +{ + stbtt_int32 i; + for (i=0;;++i) { + stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); + if (off < 0) return off; + if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) + return off; + } +} + +#endif // STB_TRUETYPE_IMPLEMENTATION diff --git a/lib/stl/include/stl/algorithm.h b/lib/stl/include/stl/algorithm.h new file mode 100644 index 0000000..802cb7e --- /dev/null +++ b/lib/stl/include/stl/algorithm.h @@ -0,0 +1,15 @@ +#ifndef __STL_ALGORITHM_H_INCLUDED__ +#define __STL_ALGORITHM_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/bitset.h b/lib/stl/include/stl/bitset.h new file mode 100644 index 0000000..5f8cfc9 --- /dev/null +++ b/lib/stl/include/stl/bitset.h @@ -0,0 +1,14 @@ +#ifndef __STL_BITSET_H_INCLUDED__ +#define __STL_BITSET_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/functional.h b/lib/stl/include/stl/functional.h new file mode 100644 index 0000000..f157123 --- /dev/null +++ b/lib/stl/include/stl/functional.h @@ -0,0 +1,14 @@ +#ifndef __STL_FUNCTIONAL_H_INCLUDED__ +#define __STL_FUNCTIONAL_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/hash_map.h b/lib/stl/include/stl/hash_map.h new file mode 100644 index 0000000..4cf991f --- /dev/null +++ b/lib/stl/include/stl/hash_map.h @@ -0,0 +1,24 @@ +#ifndef __STL_HASH_MAP_H_INCLUDED__ +#define __STL_HASH_MAP_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #ifdef _MSC_VER + #include + #elif defined(__GNUC__) + #ifdef __S3E__ + #include + #else + #include + #endif + #else + #error Unknown header location for hash_map. + #endif +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/hash_set.h b/lib/stl/include/stl/hash_set.h new file mode 100644 index 0000000..e147adc --- /dev/null +++ b/lib/stl/include/stl/hash_set.h @@ -0,0 +1,24 @@ +#ifndef __STL_HASH_SET_H_INCLUDED__ +#define __STL_HASH_SET_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #ifdef _MSC_VER + #include + #elif defined(__GNUC__) + #ifdef __S3E__ + #include + #else + #include + #endif + #else + #error Unknown header location for hash_set. + #endif +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/iterator.h b/lib/stl/include/stl/iterator.h new file mode 100644 index 0000000..a85f50b --- /dev/null +++ b/lib/stl/include/stl/iterator.h @@ -0,0 +1,14 @@ +#ifndef __STL_ITERATOR_H_INCLUDED__ +#define __STL_ITERATOR_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/list.h b/lib/stl/include/stl/list.h new file mode 100644 index 0000000..592662e --- /dev/null +++ b/lib/stl/include/stl/list.h @@ -0,0 +1,14 @@ +#ifndef __STL_LIST_H_INCLUDED__ +#define __STL_LIST_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/map.h b/lib/stl/include/stl/map.h new file mode 100644 index 0000000..ec19b49 --- /dev/null +++ b/lib/stl/include/stl/map.h @@ -0,0 +1,14 @@ +#ifndef __STL_MAP_H_INCLUDED__ +#define __STL_MAP_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/memory.h b/lib/stl/include/stl/memory.h new file mode 100644 index 0000000..4dffa68 --- /dev/null +++ b/lib/stl/include/stl/memory.h @@ -0,0 +1,14 @@ +#ifndef __STL_MEMORY_H_INCLUDED__ +#define __STL_MEMORY_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/set.h b/lib/stl/include/stl/set.h new file mode 100644 index 0000000..31ce057 --- /dev/null +++ b/lib/stl/include/stl/set.h @@ -0,0 +1,14 @@ +#ifndef __STL_SET_H_INCLUDED__ +#define __STL_SET_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/string.h b/lib/stl/include/stl/string.h new file mode 100644 index 0000000..bde0f08 --- /dev/null +++ b/lib/stl/include/stl/string.h @@ -0,0 +1,14 @@ +#ifndef __STL_STRING_H_INCLUDED__ +#define __STL_STRING_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/utility.h b/lib/stl/include/stl/utility.h new file mode 100644 index 0000000..32833ba --- /dev/null +++ b/lib/stl/include/stl/utility.h @@ -0,0 +1,14 @@ +#ifndef __STL_UTILITY_H_INCLUDED__ +#define __STL_UTILITY_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stl/vector.h b/lib/stl/include/stl/vector.h new file mode 100644 index 0000000..cdee660 --- /dev/null +++ b/lib/stl/include/stl/vector.h @@ -0,0 +1,14 @@ +#ifndef __STL_VECTOR_H_INCLUDED__ +#define __STL_VECTOR_H_INCLUDED__ + +#include + +#ifdef USE_STD_STL + #include +#elif defined(USE_EASTL_STL) + #include +#endif + +#include + +#endif diff --git a/lib/stl/include/stlconfig/namespacealias.h b/lib/stl/include/stlconfig/namespacealias.h new file mode 100644 index 0000000..ed813ee --- /dev/null +++ b/lib/stl/include/stlconfig/namespacealias.h @@ -0,0 +1,12 @@ +#ifndef __STLCONFIG_NAMESPACEALIAS_H_INCLUDED__ +#define __STLCONFIG_NAMESPACEALIAS_H_INCLUDED__ + +#ifdef USE_STD_STL +namespace stl = std; +#elif defined(USE_EASTL_STL) +namespace stl = eastl; +#else +#error Must define either USE_STD_STL or USE_EASTL_STL to choose an STL implementation. +#endif + +#endif diff --git a/lib/stl/include/stlconfig/switchstl.h b/lib/stl/include/stlconfig/switchstl.h new file mode 100644 index 0000000..054f30b --- /dev/null +++ b/lib/stl/include/stlconfig/switchstl.h @@ -0,0 +1,24 @@ +#ifndef __STLCONFIG_SWITCHSTL_H_INCLUDED__ +#define __STLCONFIG_SWITCHSTL_H_INCLUDED__ + +#if defined(USE_STD_STL) && defined(USE_EASTL_STL) + #error USE_STL_STL and USE_EASTL_STL cannot both be defined. +#endif + +// pick a default STL if an STL implementation define doesn't exist +#if !defined(USE_STD_STL) && !defined(USE_EASTL_STL) + #ifdef DEBUG + // use the standard STL for debug builds for those debuggers which + // have decent debugger visualizers for STL containers (which typically + // will only work out-of-the-box with the standard STL) + #define USE_STD_STL + #else + // for all other cases, use EASTL by default (this would be release + // builds, or where the debugger being used doesn't provide any kind of + // debugger assistance for STL containers at all and so it doesn't + // matter which one is used for debugging purposes) + #define USE_EASTL_STL + #endif +#endif + +#endif diff --git a/premake.lua b/premake.lua new file mode 100644 index 0000000..686e5f2 --- /dev/null +++ b/premake.lua @@ -0,0 +1,132 @@ +BUILD_DIR = "build" + +SDL_ROOT = os.getenv("SDL_ROOT") +if not SDL_ROOT and string.find(_ACTION, "vs") then + printf("ERROR: Environment variable SDL_ROOT is not set.") + os.exit() +end + +if _ACTION == "clean" then + os.rmdir(BUILD_DIR) +end + +solution "EngineTest" + configurations { "Debug", "Release" } + location (BUILD_DIR .. "/" .. _ACTION) + +project "EngineTest" + kind "WindowedApp" + language "C++" + location (BUILD_DIR .. "/" .. _ACTION) + files { + "./src/**.c*", + "./src/**.h", + "./lib/**.c*", + "./lib/**.h", + } + includedirs { + "./lib/stl/include", + "./lib/portable-crt/include", + "./lib/eastl/include", + "./lib/glew", + "./lib/gwen", + "./lib/stb", + } + defines { + "DESKTOP", + "SDL", + "GLEW_STATIC", + } + debugdir "." + + ---- PLATFORM SPECIFICS ---------------------------------------------------- + configuration "vs*" + flags { + "NoPCH", + "NoMinimalRebuild" + } + buildoptions { "/MP" } + links { + "SDLmain", + "SDL", + "opengl32", + "glu32", + } + defines { + "_CRT_SECURE_NO_WARNINGS", + "_CRT_NONSTDC_NO_WARNINGS" + } + includedirs { + (SDL_ROOT .. "/include"), + } + + configuration { "vs*", "Debug" } + libdirs { + (SDL_ROOT .. "/VisualC/SDL/Debug/"), + (SDL_ROOT .. "/VisualC/SDLmain/Debug/"), + } + + configuration { "vs*", "Release" } + libdirs { + (SDL_ROOT .. "/VisualC/SDL/Release/"), + (SDL_ROOT .. "/VisualC/SDLmain/Release/"), + } + + configuration "gmake" + kind "ConsoleApp" + buildoptions { "-Wall" } + + configuration { "windows", "gmake" } + kind "WindowedApp" + defines { + "_GNU_SOURCE=1", + "main=SDL_main", + } + links { + "mingw32", + "SDLmain", + "SDL", + "opengl32", + "glu32", + } + linkoptions { + "-static-libgcc", + "-static-libstdc++", + } + + configuration "macosx" + files { + "./lib/sdl-osx/**.m", + "./lib/sdl-osx/**.c*", + "./lib/sdl-osx/**.h", + } + links { + "OpenGL.framework", + "SDL.framework", + "Cocoa.framework", + } + includedirs { + "/Library/Frameworks/SDL.framework/Headers", + "/System/Library/Frameworks/OpenGL.framework/Headers", + } + + configuration "linux" + links { + "SDL", + "GL", + "GLU", + } + ---------------------------------------------------------------------------- + + configuration "Debug" + defines { + "DEBUG", + "DEBUG_ASSERT_BREAK", + } + flags { "Symbols" } + + configuration "Release" + defines { + "NDEBUG", + } + flags { "Optimize" } diff --git a/src/contexts/contentcache.cpp b/src/contexts/contentcache.cpp new file mode 100644 index 0000000..7831b4a --- /dev/null +++ b/src/contexts/contentcache.cpp @@ -0,0 +1,41 @@ +#include "../framework/common.h" +#include "../framework/debug.h" + +#include "contentcache.h" + +#include "../framework/content/contentmanager.h" +#include "../framework/content/spritefontparam.h" +#include "../framework/graphics/gridtextureatlas.h" +#include "../framework/graphics/image.h" +#include "../framework/graphics/spritefont.h" +#include "../framework/graphics/texture.h" +#include "../framework/graphics/textureatlas.h" + +ContentCache::ContentCache(ContentManager *contentManager) +{ + STACK_TRACE; + m_contentManager = contentManager; + m_uiFontSize = 0; +} + +ContentCache::~ContentCache() +{ + STACK_TRACE; + m_contentManager->Free(m_uiSkin, TRUE); + m_contentManager->Free(m_uiSkinImage, TRUE); + m_contentManager->Free(m_standardFont, TRUE); + m_contentManager->Free(m_uiFont, TRUE); +} + +void ContentCache::OnLoadGame() +{ + STACK_TRACE; + m_uiSkinFilename = "assets://ui_skin.png"; + m_uiSkinImage = m_contentManager->Get(m_uiSkinFilename, TRUE); + m_uiSkin = m_contentManager->Get(m_uiSkinFilename, TRUE); + m_standardFont = m_contentManager->Get("assets://fonts/dlxfont.ttf", SpriteFontParam(8), TRUE); + m_uiFontFilename = "assets://fonts/dlxfont.ttf"; + m_uiFontSize = 8; + m_uiFont = m_contentManager->Get(m_uiFontFilename, SpriteFontParam(m_uiFontSize), TRUE); +} + diff --git a/src/contexts/contentcache.h b/src/contexts/contentcache.h new file mode 100644 index 0000000..a9d8787 --- /dev/null +++ b/src/contexts/contentcache.h @@ -0,0 +1,43 @@ +#ifndef __CONTEXTS_CONTENTCACHE_H_INCLUDED__ +#define __CONTEXTS_CONTENTCACHE_H_INCLUDED__ + +#include "../framework/common.h" + +class ContentManager; +class Image; +class SpriteFont; +class Texture; +class TextureAtlas; + +#include + +class ContentCache +{ +public: + ContentCache(ContentManager *contentManager); + virtual ~ContentCache(); + + void OnLoadGame(); + + Texture* GetUISkin() const { return m_uiSkin; } + Image* GetUISkinImage() const { return m_uiSkinImage; } + const stl::string& GetUISkinFilename() const { return m_uiSkinFilename; } + SpriteFont* GetFont() const { return m_standardFont; } + SpriteFont* GetUIFont() const { return m_uiFont; } + const stl::string& GetUIFontFilename() const { return m_uiFontFilename; } + uint8_t GetUIFontSize() const { return m_uiFontSize; } + +private: + ContentManager *m_contentManager; + + Texture *m_uiSkin; + Image *m_uiSkinImage; + stl::string m_uiSkinFilename; + SpriteFont *m_standardFont; + SpriteFont *m_uiFont; + stl::string m_uiFontFilename; + uint8_t m_uiFontSize; +}; + +#endif + diff --git a/src/contexts/rendercontext.cpp b/src/contexts/rendercontext.cpp new file mode 100644 index 0000000..f2a3d04 --- /dev/null +++ b/src/contexts/rendercontext.cpp @@ -0,0 +1,104 @@ +#include "../framework/debug.h" + +#include "rendercontext.h" + +#include "../framework/assets/animation/keyframemeshrenderer.h" +#include "../framework/assets/animation/skeletalmeshrenderer.h" +#include "../framework/assets/static/staticmeshrenderer.h" +#include "../framework/content/contentmanager.h" +#include "../framework/graphics/billboardspritebatch.h" +#include "../framework/graphics/geometrydebugrenderer.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/renderstate.h" +#include "../framework/graphics/spritebatch.h" +#include "../framework/graphics/viewcontext.h" +#include "../framework/support/text.h" + +RenderContext::RenderContext(GraphicsDevice *graphicsDevice, ContentManager *contentManager) +{ + STACK_TRACE; + ASSERT(graphicsDevice != NULL); + ASSERT(contentManager != NULL); + + m_graphicsDevice = graphicsDevice; + m_contentManager = contentManager; + + m_spriteBatch = new SpriteBatch(m_graphicsDevice); + m_billboardSpriteBatch = new BillboardSpriteBatch(m_graphicsDevice); + m_keyframeMeshRenderer = new KeyframeMeshRenderer(); + m_skeletalMeshRenderer = new SkeletalMeshRenderer(); + m_staticMeshRenderer = new StaticMeshRenderer(); + + CalculateScreenScale(); +} + +RenderContext::~RenderContext() +{ + STACK_TRACE; + SAFE_DELETE(m_spriteBatch); + SAFE_DELETE(m_billboardSpriteBatch); + SAFE_DELETE(m_keyframeMeshRenderer); + SAFE_DELETE(m_skeletalMeshRenderer); + SAFE_DELETE(m_staticMeshRenderer); +} + +void RenderContext::OnLoadGame() +{ + STACK_TRACE; +} + +void RenderContext::OnPreRender() +{ + STACK_TRACE; + RENDERSTATE_DEFAULT.Apply(); + BLENDSTATE_DEFAULT.Apply(); + + m_graphicsDevice->GetDebugRenderer()->Begin(); + m_spriteBatch->Begin(); + m_billboardSpriteBatch->Begin(); +} + +void RenderContext::OnPostRender() +{ + STACK_TRACE; + m_billboardSpriteBatch->End(); + m_spriteBatch->End(); + m_graphicsDevice->GetDebugRenderer()->End(); +} + +void RenderContext::OnResize() +{ + STACK_TRACE; + CalculateScreenScale(); +} + +void RenderContext::CalculateScreenScale() +{ + STACK_TRACE; + uint16_t width = m_graphicsDevice->GetViewContext()->GetViewportWidth(); + uint16_t height = m_graphicsDevice->GetViewContext()->GetViewportHeight(); + + // TODO: these values may need adjusting + + m_screenScale = 1; + + if (width < 640 || height < 480) + return; + + m_screenScale = 2; + + if (width < 960 || height < 720) + return; + + m_screenScale = 3; + + if (width < 1280 || height < 960) + return; + + m_screenScale = 4; + + if (width < 1920 || height < 1080) + return; + + m_screenScale = 5; +} diff --git a/src/contexts/rendercontext.h b/src/contexts/rendercontext.h new file mode 100644 index 0000000..11ef0d0 --- /dev/null +++ b/src/contexts/rendercontext.h @@ -0,0 +1,52 @@ +#ifndef __CONTEXTS_RENDERCONTEXT_H_INCLUDED__ +#define __CONTEXTS_RENDERCONTEXT_H_INCLUDED__ + +#include "../framework/common.h" + +#include "../framework/graphics/color.h" +#include "../framework/math/vector3.h" + +class BillboardSpriteBatch; +class ContentManager; +class GraphicsDevice; +class KeyframeMeshRenderer; +class SkeletalMeshRenderer; +class SpriteBatch; +class StaticMeshRenderer; + +class RenderContext +{ +public: + RenderContext(GraphicsDevice *graphicsDevice, ContentManager *contentManager); + virtual ~RenderContext(); + + void OnLoadGame(); + void OnPreRender(); + void OnPostRender(); + void OnResize(); + + GraphicsDevice* GetGraphicsDevice() const { return m_graphicsDevice; } + SpriteBatch* GetSpriteBatch() const { return m_spriteBatch; } + BillboardSpriteBatch* GetBillboardSpriteBatch() const { return m_billboardSpriteBatch; } + KeyframeMeshRenderer* GetKeyframeMeshRenderer() const { return m_keyframeMeshRenderer; } + SkeletalMeshRenderer* GetSkeletalMeshRenderer() const { return m_skeletalMeshRenderer; } + StaticMeshRenderer* GetStaticMeshRenderer() const { return m_staticMeshRenderer; } + + uint32_t GetScreenScale() const { return m_screenScale; } + +private: + void CalculateScreenScale(); + + ContentManager *m_contentManager; + GraphicsDevice *m_graphicsDevice; + SpriteBatch *m_spriteBatch; + BillboardSpriteBatch *m_billboardSpriteBatch; + KeyframeMeshRenderer *m_keyframeMeshRenderer; + SkeletalMeshRenderer *m_skeletalMeshRenderer; + StaticMeshRenderer *m_staticMeshRenderer; + + uint32_t m_screenScale; +}; + +#endif + diff --git a/src/effects/dimeffect.cpp b/src/effects/dimeffect.cpp new file mode 100644 index 0000000..d89c6b8 --- /dev/null +++ b/src/effects/dimeffect.cpp @@ -0,0 +1,40 @@ +#include "../framework/debug.h" + +#include "dimeffect.h" +#include "../contexts/rendercontext.h" +#include "../framework/graphics/color.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/spritebatch.h" +#include "../framework/graphics/viewcontext.h" + +const float DEFAULT_DIM_ALPHA = 0.5f; +const Color DEFAULT_DIM_COLOR = COLOR_BLACK; + +DimEffect::DimEffect() + : Effect() +{ + STACK_TRACE; + m_alpha = DEFAULT_DIM_ALPHA; + m_color = DEFAULT_DIM_COLOR; +} + +DimEffect::~DimEffect() +{ + STACK_TRACE; +} + +void DimEffect::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + uint16_t width = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportWidth(); + uint16_t height = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportHeight(); + + m_color.a = m_alpha; + renderContext->GetSpriteBatch()->Render( + renderContext->GetGraphicsDevice()->GetSolidColorTexture(COLOR_WHITE), + 0, 0, + width, height, + m_color + ); +} + diff --git a/src/effects/dimeffect.h b/src/effects/dimeffect.h new file mode 100644 index 0000000..2dabf4b --- /dev/null +++ b/src/effects/dimeffect.h @@ -0,0 +1,46 @@ +#ifndef __EFFECTS_DIMEFFECT_H_INCLUDED__ +#define __EFFECTS_DIMEFFECT_H_INCLUDED__ + +#include "../framework/common.h" +#include "effect.h" +#include "../framework/graphics/color.h" + +class RenderContext; + +class DimEffect : public Effect +{ +public: + static EFFECT_TYPE GetType() + { + static EFFECT_TYPE typeName = "DimEffect"; + return typeName; + } + EFFECT_TYPE GetTypeOf() const { return GetType(); } + + DimEffect(); + virtual ~DimEffect(); + + void OnRender(RenderContext *renderContext); + + DimEffect* SetColor(const Color &color); + DimEffect* SetAlpha(float alpha); + +private: + float m_alpha; + Color m_color; +}; + +inline DimEffect* DimEffect::SetColor(const Color &color) +{ + m_color = color; + return this; +} + +inline DimEffect* DimEffect::SetAlpha(float alpha) +{ + m_alpha = alpha; + return this; +} + +#endif + diff --git a/src/effects/effect.h b/src/effects/effect.h new file mode 100644 index 0000000..ae148b4 --- /dev/null +++ b/src/effects/effect.h @@ -0,0 +1,86 @@ +#ifndef __EFFECTS_EFFECT_H_INCLUDED__ +#define __EFFECTS_EFFECT_H_INCLUDED__ + +#include "../framework/common.h" + +class RenderContext; + +typedef const char* EFFECT_TYPE; + +class Effect +{ +public: + Effect(); + virtual ~Effect(); + + virtual void OnAdd() {}; + virtual void OnRemove() {}; + virtual void OnAppGainFocus() {}; + virtual void OnAppLostFocus() {}; + virtual void OnAppPause() {}; + virtual void OnAppResume() {}; + virtual void OnLostContext() {}; + virtual void OnNewContext() {}; + virtual void OnRender(RenderContext *renderContext) {}; + virtual void OnResize() {}; + virtual void OnUpdate(float delta) {}; + + BOOL IsActive() const { return m_isActive; } + void MarkInactive(); + + virtual EFFECT_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(EFFECT_TYPE type) const; + template T* As(); + template const T* As() const; + +private: + BOOL m_isActive; +}; + +inline Effect::Effect() +{ + m_isActive = TRUE; +} + +inline Effect::~Effect() +{ +} + +inline void Effect::MarkInactive() +{ + m_isActive = FALSE; +} + +template +inline BOOL Effect::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL Effect::Is(EFFECT_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* Effect::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* Effect::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/effects/effectinfo.cpp b/src/effects/effectinfo.cpp new file mode 100644 index 0000000..150a81c --- /dev/null +++ b/src/effects/effectinfo.cpp @@ -0,0 +1,19 @@ +#include "../framework/debug.h" + +#include "effectinfo.h" +#include "effect.h" + +EffectInfo::EffectInfo(Effect *effect, BOOL isLocal) +{ + STACK_TRACE; + ASSERT(effect != NULL); + m_effect = effect; + m_isLocal = isLocal; +} + +EffectInfo::~EffectInfo() +{ + STACK_TRACE; + SAFE_DELETE(m_effect); +} + diff --git a/src/effects/effectinfo.h b/src/effects/effectinfo.h new file mode 100644 index 0000000..0585d59 --- /dev/null +++ b/src/effects/effectinfo.h @@ -0,0 +1,23 @@ +#ifndef __EFFECTS_EFFECTINFO_H_INCLUDED__ +#define __EFFECTS_EFFECTINFO_H_INCLUDED__ + +#include "../framework/common.h" + +class Effect; + +class EffectInfo +{ +public: + EffectInfo(Effect *effect, BOOL isLocal); + virtual ~EffectInfo(); + + Effect* GetEffect() const { return m_effect; } + BOOL IsLocal() const { return m_isLocal; } + +private: + Effect *m_effect; + BOOL m_isLocal; +}; + +#endif + diff --git a/src/effects/effectmanager.cpp b/src/effects/effectmanager.cpp new file mode 100644 index 0000000..d22681b --- /dev/null +++ b/src/effects/effectmanager.cpp @@ -0,0 +1,146 @@ +#include "../framework/debug.h" + +#include "effectmanager.h" +#include "effect.h" + +EffectManager::EffectManager() +{ + STACK_TRACE; + m_numLocalEffects = 0; + m_numGlobalEffects = 0; +} + +EffectManager::~EffectManager() +{ + STACK_TRACE; + RemoveAll(); +} + +void EffectManager::RemoveAll() +{ + STACK_TRACE; + EffectListItor itor = m_effects.begin(); + while (itor != m_effects.end()) + Remove(itor++); +} + +void EffectManager::Add(EFFECT_TYPE type, EffectInfo *effectInfo) +{ + STACK_TRACE; + ASSERT(effectInfo != NULL); + m_effects.insert(EffectList::value_type(type, effectInfo)); + effectInfo->GetEffect()->OnAdd(); + + if (effectInfo->IsLocal()) + ++m_numLocalEffects; + else + ++m_numGlobalEffects; +} + +void EffectManager::Remove(EffectListItor itor) +{ + STACK_TRACE; + if (itor->second->IsLocal()) + --m_numLocalEffects; + else + --m_numGlobalEffects; + + itor->second->GetEffect()->OnRemove(); + SAFE_DELETE(itor->second); + m_effects.erase(itor); +} + +void EffectManager::OnAppGainFocus() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnAppGainFocus(); +} + +void EffectManager::OnAppLostFocus() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnAppLostFocus(); +} + +void EffectManager::OnAppPause() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnAppPause(); +} + +void EffectManager::OnAppResume() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnAppResume(); +} + +void EffectManager::OnLostContext() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnLostContext(); +} + +void EffectManager::OnNewContext() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnNewContext(); +} + +void EffectManager::OnRenderLocal(RenderContext *renderContext) +{ + STACK_TRACE; + if (m_numLocalEffects == 0) + return; + + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + { + if (itor->second->IsLocal()) + itor->second->GetEffect()->OnRender(renderContext); + } +} + +void EffectManager::OnRenderGlobal(RenderContext *renderContext) +{ + STACK_TRACE; + if (m_numGlobalEffects == 0) + return; + + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + { + if (!itor->second->IsLocal()) + itor->second->GetEffect()->OnRender(renderContext); + } +} + +void EffectManager::OnResize() +{ + STACK_TRACE; + for (EffectListItor itor = m_effects.begin(); itor != m_effects.end(); ++itor) + itor->second->GetEffect()->OnResize(); +} + +void EffectManager::OnUpdate(float delta) +{ + STACK_TRACE; + EffectListItor itor = m_effects.begin(); + while (itor != m_effects.end()) + { + Effect *effect = itor->second->GetEffect(); + if (!effect->IsActive()) + { + Remove(itor++); + } + else + { + effect->OnUpdate(delta); + ++itor; + } + } +} + diff --git a/src/effects/effectmanager.h b/src/effects/effectmanager.h new file mode 100644 index 0000000..537184d --- /dev/null +++ b/src/effects/effectmanager.h @@ -0,0 +1,83 @@ +#ifndef __EFFECTS_EFFECTMANAGER_H_INCLUDED__ +#define __EFFECTS_EFFECTMANAGER_H_INCLUDED__ + +#include "../framework/common.h" +#include "../framework/debug.h" +#include + +#include "effect.h" +#include "effectinfo.h" + +class RenderContext; + +typedef stl::map EffectList; +typedef stl::map::iterator EffectListItor; +typedef stl::map::const_iterator EffectListConstItor; + +class EffectManager +{ +public: + EffectManager(); + virtual ~EffectManager(); + + template T* Get() const; + template T* Add(BOOL isLocalEffect = TRUE); + template void Remove(); + void RemoveAll(); + + void OnAppGainFocus(); + void OnAppLostFocus(); + void OnAppPause(); + void OnAppResume(); + void OnLostContext(); + void OnNewContext(); + void OnRenderLocal(RenderContext *renderContext); + void OnRenderGlobal(RenderContext *renderContext); + void OnResize(); + void OnUpdate(float delta); + +private: + void Add(EFFECT_TYPE type, EffectInfo *effectInfo); + void Remove(EffectListItor itor); + + EffectList m_effects; + uint32_t m_numLocalEffects; + uint32_t m_numGlobalEffects; +}; + +template +T* EffectManager::Get() const +{ + EffectListConstItor itor = m_effects.find(T::GetType()); + if (itor == m_effects.end()) + return NULL; + else + return (T*)itor->second->GetEffect(); +} + +template +T* EffectManager::Add(BOOL isLocalEffect) +{ + STACK_TRACE; + if (Get() != NULL) + return NULL; + + T* effect = new T(); + EffectInfo *newEffectInfo = new EffectInfo(effect, isLocalEffect); + Add(T::GetType(), newEffectInfo); + + return effect; +} + +template +void EffectManager::Remove() +{ + STACK_TRACE; + EffectListItor itor = m_effects.find(T::GetType()); + ASSERT(itor != m_effects.end()); + + Remove(itor); +} + +#endif + diff --git a/src/effects/fadeeffect.cpp b/src/effects/fadeeffect.cpp new file mode 100644 index 0000000..a13af33 --- /dev/null +++ b/src/effects/fadeeffect.cpp @@ -0,0 +1,71 @@ +#include "../framework/debug.h" + +#include "fadeeffect.h" +#include "../contexts/rendercontext.h" +#include "../framework/graphics/color.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/spritebatch.h" +#include "../framework/graphics/texture.h" +#include "../framework/graphics/viewcontext.h" + +const float DEFAULT_FADE_SPEED = 3.0f; +const Color DEFAULT_FADE_COLOR = COLOR_BLACK; + +FadeEffect::FadeEffect() + : Effect() +{ + STACK_TRACE; + m_doneFading = FALSE; + m_fadeSpeed = DEFAULT_FADE_SPEED; + m_fadingOut = TRUE; + m_alpha = 0.0f; + m_color = DEFAULT_FADE_COLOR; + m_fadeToAlpha = 0.0f; +} + +FadeEffect::~FadeEffect() +{ + STACK_TRACE; +} + +void FadeEffect::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + uint16_t width = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportWidth(); + uint16_t height = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportHeight(); + + m_color.a = m_alpha; + renderContext->GetSpriteBatch()->Render( + renderContext->GetGraphicsDevice()->GetSolidColorTexture(COLOR_WHITE), + 0, 0, + width, height, + m_color + ); +} + +void FadeEffect::OnUpdate(float delta) +{ + STACK_TRACE; + if (m_doneFading) + return; + + if (m_fadingOut) + { + m_alpha += (delta * m_fadeSpeed); + if (m_alpha >= m_fadeToAlpha) + { + m_alpha = m_fadeToAlpha; + m_doneFading = TRUE; + } + } + else + { + m_alpha -= (delta * m_fadeSpeed); + if (m_alpha < m_fadeToAlpha) + { + m_alpha = m_fadeToAlpha; + m_doneFading = TRUE; + } + } +} + diff --git a/src/effects/fadeeffect.h b/src/effects/fadeeffect.h new file mode 100644 index 0000000..23b16c0 --- /dev/null +++ b/src/effects/fadeeffect.h @@ -0,0 +1,71 @@ +#ifndef __EFFECTS_FADEEFFECT_H_INCLUDED__ +#define __EFFECTS_FADEEFFECT_H_INCLUDED__ + +#include "../framework/common.h" +#include "effect.h" +#include "../framework/graphics/color.h" + +class RenderContext; + +class FadeEffect : public Effect +{ +public: + static EFFECT_TYPE GetType() + { + static EFFECT_TYPE typeName = "FadeEffect"; + return typeName; + } + EFFECT_TYPE GetTypeOf() const { return GetType(); } + + FadeEffect(); + virtual ~FadeEffect(); + + void OnRender(RenderContext *renderContext); + void OnUpdate(float delta); + + FadeEffect* SetColor(const Color &color); + FadeEffect* SetFadeSpeed(float speed); + FadeEffect* SetFadeOut(float toAlpha = COLOR_ALPHA_OPAQUE); + FadeEffect* SetFadeIn(float toAlpha = COLOR_ALPHA_TRANSPARENT); + + BOOL IsDoneFading() const { return m_doneFading; } + +private: + BOOL m_doneFading; + float m_fadeSpeed; + BOOL m_fadingOut; + float m_alpha; + Color m_color; + float m_fadeToAlpha; +}; + +inline FadeEffect* FadeEffect::SetColor(const Color &color) +{ + m_color = color; + return this; +} + +inline FadeEffect* FadeEffect::SetFadeSpeed(float speed) +{ + m_fadeSpeed = speed; + return this; +} + +inline FadeEffect* FadeEffect::SetFadeOut(float toAlpha) +{ + m_fadingOut = TRUE; + m_alpha = COLOR_ALPHA_TRANSPARENT; + m_fadeToAlpha = toAlpha; + return this; +} + +inline FadeEffect* FadeEffect::SetFadeIn(float toAlpha) +{ + m_fadingOut = FALSE; + m_alpha = COLOR_ALPHA_OPAQUE; + m_fadeToAlpha = toAlpha; + return this; +} + +#endif + diff --git a/src/effects/flasheffect.cpp b/src/effects/flasheffect.cpp new file mode 100644 index 0000000..431a929 --- /dev/null +++ b/src/effects/flasheffect.cpp @@ -0,0 +1,68 @@ +#include "../framework/debug.h" + +#include "flasheffect.h" +#include "../contexts/rendercontext.h" +#include "../framework/graphics/color.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/spritebatch.h" +#include "../framework/graphics/texture.h" +#include "../framework/graphics/viewcontext.h" + +const float DEFAULT_FLASH_SPEED = 16.0f; +const float DEFAULT_MAX_INTENSITY = 1.0f; + +FlashEffect::FlashEffect() + : Effect() +{ + STACK_TRACE; + m_flashingIn = TRUE; + m_flashInSpeed = DEFAULT_FLASH_SPEED; + m_flashOutSpeed = DEFAULT_FLASH_SPEED; + m_maximumIntensity = DEFAULT_MAX_INTENSITY; + m_alpha = 0.0f; + m_color = COLOR_BLACK; +} + +FlashEffect::~FlashEffect() +{ + STACK_TRACE; +} + +void FlashEffect::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + uint16_t width = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportWidth(); + uint16_t height = renderContext->GetGraphicsDevice()->GetViewContext()->GetViewportHeight(); + + m_color.a = m_alpha; + renderContext->GetSpriteBatch()->Render( + renderContext->GetGraphicsDevice()->GetSolidColorTexture(COLOR_WHITE), + 0, 0, + width, height, + m_color + ); +} + +void FlashEffect::OnUpdate(float delta) +{ + STACK_TRACE; + if (m_flashingIn) + { + m_alpha += (delta * m_flashInSpeed); + if (m_alpha >= m_maximumIntensity) + { + m_alpha = m_maximumIntensity; + m_flashingIn = FALSE; + } + } + else + { + m_alpha -= (delta * m_flashOutSpeed); + if (m_alpha < 0.0f) + m_alpha = 0.0f; + } + + if (m_alpha == 0.0f && m_flashingIn == FALSE) + MarkInactive(); +} + diff --git a/src/effects/flasheffect.h b/src/effects/flasheffect.h new file mode 100644 index 0000000..21d1dc8 --- /dev/null +++ b/src/effects/flasheffect.h @@ -0,0 +1,65 @@ +#ifndef __EFFECTS_FLASHEFFECT_H_INCLUDED__ +#define __EFFECTS_FLASHEFFECT_H_INCLUDED__ + +#include "../framework/common.h" +#include "effect.h" +#include "../framework/graphics/color.h" + +class RenderContext; + +class FlashEffect : public Effect +{ +public: + static EFFECT_TYPE GetType() + { + static EFFECT_TYPE typeName = "FlashEffect"; + return typeName; + } + EFFECT_TYPE GetTypeOf() const { return GetType(); } + + FlashEffect(); + virtual ~FlashEffect(); + + void OnRender(RenderContext *renderContext); + void OnUpdate(float delta); + + FlashEffect* SetColor(const Color &color); + FlashEffect* SetFlashInSpeed(float speed); + FlashEffect* SetFlashOutSpeed(float speed); + FlashEffect* SetMaximumIntensity(float maxIntensity); + +private: + BOOL m_flashingIn; + float m_flashInSpeed; + float m_flashOutSpeed; + float m_maximumIntensity; + float m_alpha; + Color m_color; +}; + +inline FlashEffect* FlashEffect::SetColor(const Color &color) +{ + m_color = color; + return this; +} + +inline FlashEffect* FlashEffect::SetFlashInSpeed(float speed) +{ + m_flashInSpeed = speed; + return this; +} + +inline FlashEffect* FlashEffect::SetFlashOutSpeed(float speed) +{ + m_flashOutSpeed = speed; + return this; +} + +inline FlashEffect* FlashEffect::SetMaximumIntensity(float maxIntensity) +{ + m_maximumIntensity = maxIntensity; + return this; +} + +#endif + diff --git a/src/entities/component.h b/src/entities/component.h new file mode 100644 index 0000000..2dbcd74 --- /dev/null +++ b/src/entities/component.h @@ -0,0 +1,60 @@ +#ifndef __ENTITIES_COMPONENT_H_INCLUDED__ +#define __ENTITIES_COMPONENT_H_INCLUDED__ + +#include "../framework/common.h" + +typedef const char* COMPONENT_TYPE; + +class Component +{ +public: + virtual ~Component(); + virtual void Reset(); + + virtual COMPONENT_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(COMPONENT_TYPE type) const; + template T* As(); + template const T* As() const; +}; + +inline Component::~Component() +{ +} + +inline void Component::Reset() +{ +} + +template +inline BOOL Component::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL Component::Is(COMPONENT_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* Component::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* Component::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/entities/components/entitypresetcomponent.h b/src/entities/components/entitypresetcomponent.h new file mode 100644 index 0000000..2d57af4 --- /dev/null +++ b/src/entities/components/entitypresetcomponent.h @@ -0,0 +1,34 @@ +#ifndef __GAME_ENTITIES_COMPONENTS_ENTITYPRESETCOMPONENT_H_INCLUDED__ +#define __GAME_ENTITIES_COMPONENTS_ENTITYPRESETCOMPONENT_H_INCLUDED__ + +#include "../component.h" +#include "../entitypreset.h" + +class EntityPresetComponent : public Component +{ +public: + static COMPONENT_TYPE GetType() + { + static COMPONENT_TYPE typeName = "EntityPresetComponent"; + return typeName; + } + COMPONENT_TYPE GetTypeOf() const { return GetType(); } + + EntityPresetComponent(); + void Reset(); + + ENTITYPRESET_TYPE preset; +}; + +inline EntityPresetComponent::EntityPresetComponent() +{ + Reset(); +} + +inline void EntityPresetComponent::Reset() +{ + preset = NULL; +} + +#endif + diff --git a/src/entities/components/inactivecomponent.h b/src/entities/components/inactivecomponent.h new file mode 100644 index 0000000..a39fc2b --- /dev/null +++ b/src/entities/components/inactivecomponent.h @@ -0,0 +1,18 @@ +#ifndef __ENTITIES_COMPONENTS_INACTIVECOMPONENT_H_INCLUDED__ +#define __ENTITIES_COMPONENTS_INACTIVECOMPONENT_H_INCLUDED__ + +#include "../component.h" + +class InactiveComponent : public Component +{ +public: + static COMPONENT_TYPE GetType() + { + static COMPONENT_TYPE typeName = "InactiveComponent"; + return typeName; + } + COMPONENT_TYPE GetTypeOf() const { return GetType(); } +}; + +#endif + diff --git a/src/entities/componentsystem.h b/src/entities/componentsystem.h new file mode 100644 index 0000000..adc5b53 --- /dev/null +++ b/src/entities/componentsystem.h @@ -0,0 +1,88 @@ +#ifndef __ENTITIES_COMPONENTSYSTEM_H_INCLUDED__ +#define __ENTITIES_COMPONENTSYSTEM_H_INCLUDED__ + +#include "../framework/common.h" +#include "../events/eventlistenerex.h" + +class EntityManager; +class EventManager; +class RenderContext; +struct Event; + +typedef const char* COMPONENTSYSTEM_TYPE; + +class ComponentSystem : public EventListenerEx +{ +public: + virtual ~ComponentSystem(); + + virtual void OnLostContext() {} + virtual void OnNewContext() {} + virtual void OnRender(RenderContext *renderContext) {} + virtual void OnResize() {} + virtual void OnUpdate(float delta) {} + + virtual BOOL Handle(const Event *event); + + virtual COMPONENTSYSTEM_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(COMPONENTSYSTEM_TYPE type) const; + template T* As(); + template const T* As() const; + +protected: + ComponentSystem(EntityManager *entityManager, EventManager *eventManager); + + EntityManager* GetEntityManager() const { return m_entityManager; } + +private: + EntityManager *m_entityManager; +}; + +inline ComponentSystem::ComponentSystem(EntityManager *entityManager, EventManager *eventManager) + : EventListenerEx(eventManager) +{ + m_entityManager = entityManager; +} + +inline ComponentSystem::~ComponentSystem() +{ +} + +inline BOOL ComponentSystem::Handle(const Event *event) +{ + return FALSE; +} + +template +inline BOOL ComponentSystem::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL ComponentSystem::Is(COMPONENTSYSTEM_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* ComponentSystem::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* ComponentSystem::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/entities/entity.cpp b/src/entities/entity.cpp new file mode 100644 index 0000000..47be68f --- /dev/null +++ b/src/entities/entity.cpp @@ -0,0 +1,17 @@ +#include "../framework/debug.h" +#include "../framework/common.h" + +#include "entity.h" +#include "entitymanager.h" + +Entity::Entity(EntityManager *entityManager) +{ + STACK_TRACE; + m_entityManager = entityManager; +} + +Entity::~Entity() +{ + STACK_TRACE; +} + diff --git a/src/entities/entity.h b/src/entities/entity.h new file mode 100644 index 0000000..78fce60 --- /dev/null +++ b/src/entities/entity.h @@ -0,0 +1,63 @@ +#ifndef __ENTITIES_ENTITY_H_INCLUDED__ +#define __ENTITIES_ENTITY_H_INCLUDED__ + +#include "../framework/common.h" + +#include "entitymanager.h" +#include "entitypreset.h" + +class Entity +{ +public: + Entity(EntityManager *entityManager); + virtual ~Entity(); + + template T* Get() const; + template T* Add(); + template void Remove(); + template BOOL Has() const; + + template BOOL WasCreatedUsingPreset() const; + BOOL WasCreatedUsingPreset(ENTITYPRESET_TYPE type) const; + +protected: + EntityManager *m_entityManager; +}; + +template +inline T* Entity::Get() const +{ + return m_entityManager->GetComponent(this); +} + +template +inline T* Entity::Add() +{ + return m_entityManager->AddComponent(this); +} + +template +inline void Entity::Remove() +{ + m_entityManager->RemoveComponent(this); +} + +template +inline BOOL Entity::Has() const +{ + return m_entityManager->HasComponent(this); +} + +template +inline BOOL Entity::WasCreatedUsingPreset() const +{ + return m_entityManager->WasCreatedUsingPreset(this); +} + +inline BOOL Entity::WasCreatedUsingPreset(ENTITYPRESET_TYPE type) const +{ + return m_entityManager->WasCreatedUsingPreset(this, type); +} + +#endif + diff --git a/src/entities/entitymanager.cpp b/src/entities/entitymanager.cpp new file mode 100644 index 0000000..4942ccf --- /dev/null +++ b/src/entities/entitymanager.cpp @@ -0,0 +1,214 @@ +#include "../framework/debug.h" + +#include "entitymanager.h" +#include "componentsystem.h" +#include "entity.h" +#include "entitypreset.h" +#include "components/entitypresetcomponent.h" +#include "components/inactivecomponent.h" + +EntityManager::EntityManager(EventManager *eventManager) +{ + STACK_TRACE; + m_eventManager = eventManager; +} + +EntityManager::~EntityManager() +{ + STACK_TRACE; + RemoveAll(); + RemoveAllSubsystems(); + RemoveAllPresets(); + RemoveAllGlobalComponents(); +} + +void EntityManager::RemoveAllSubsystems() +{ + STACK_TRACE; + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + SAFE_DELETE(*i); + + m_componentSystems.clear(); +} + +void EntityManager::RemoveAllPresets() +{ + STACK_TRACE; + while (!m_entityPresets.empty()) + { + EntityPresetMap::iterator i = m_entityPresets.begin(); + + EntityPreset *preset = i->second; + SAFE_DELETE(preset); + + m_entityPresets.erase(i); + } +} + +Entity* EntityManager::Add() +{ + STACK_TRACE; + Entity *entity = new Entity(this); + m_entities.insert(entity); + return entity; +} + +Entity* EntityManager::AddUsingPreset(ENTITYPRESET_TYPE preset, EntityPresetArgs *args) +{ + STACK_TRACE; + EntityPresetMap::iterator i = m_entityPresets.find(preset); + ASSERT(i != m_entityPresets.end()); + if (i == m_entityPresets.end()) + return NULL; + + Entity *entity = i->second->Create(args); + ASSERT(entity != NULL); + if (entity == NULL) + return NULL; + + entity->Add()->preset = preset; + + return entity; +} + +BOOL EntityManager::WasCreatedUsingPreset(const Entity *entity, ENTITYPRESET_TYPE type) const +{ + STACK_TRACE; + ASSERT(entity != NULL); + ASSERT(type != NULL); + EntityPresetComponent *preset = entity->Get(); + if (preset != NULL && preset->preset == type) + return TRUE; + else + return FALSE; +} + +void EntityManager::Remove(Entity *entity) +{ + STACK_TRACE; + ASSERT(entity != NULL); + if (!IsValid(entity)) + return; + + EntitySet::iterator itor = m_entities.find(entity); + + RemoveAllComponentsFrom(entity); + + m_entities.erase(itor); + SAFE_DELETE(entity); +} + +void EntityManager::RemoveAll() +{ + STACK_TRACE; + for (EntitySet::iterator i = m_entities.begin(); i != m_entities.end(); ++i) + { + Entity *entity = *i; + RemoveAllComponentsFrom(entity); + SAFE_DELETE(entity); + } + + m_entities.clear(); +} + +void EntityManager::RemoveAllComponentsFrom(Entity *entity) +{ + STACK_TRACE; + ASSERT(entity != NULL); + + for (ComponentStore::iterator i = m_components.begin(); i != m_components.end(); ++i) + { + EntityComponentsMap &entitiesWithComponent = i->second; + EntityComponentsMap::iterator j = entitiesWithComponent.find(entity); + if (j != entitiesWithComponent.end()) + { + SAFE_DELETE(j->second); + entitiesWithComponent.erase(entity); + } + } +} + +BOOL EntityManager::IsValid(const Entity *entity) const +{ + if (entity == NULL) + return FALSE; + + // HACK: lol, this cast is aboslutely terrible and I shouldn't be doing this + EntitySet::const_iterator i = m_entities.find((Entity*)entity); + if (i == m_entities.end()) + return FALSE; + else + return TRUE; +} + +void EntityManager::GetAllComponentsFor(const Entity *entity, ComponentList &list) const +{ + STACK_TRACE; + ASSERT(entity != NULL); + if (!IsValid(entity)) + return; + + for (ComponentStore::const_iterator i = m_components.begin(); i != m_components.end(); ++i) + { + const EntityComponentsMap &entitiesWithComponent = i->second; + EntityComponentsMap::const_iterator j = entitiesWithComponent.find(entity); + if (j != entitiesWithComponent.end()) + list.push_back(j->second); + } +} + +void EntityManager::RemoveAllGlobalComponents() +{ + STACK_TRACE; + while (!m_globalComponents.empty()) + { + GlobalComponentStore::iterator i = m_globalComponents.begin(); + + GlobalComponent *component = i->second; + SAFE_DELETE(component); + + m_globalComponents.erase(i); + } +} + +void EntityManager::OnLostContext() +{ + STACK_TRACE; + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + (*i)->OnLostContext(); +} + +void EntityManager::OnNewContext() +{ + STACK_TRACE; + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + (*i)->OnNewContext(); +} + +void EntityManager::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + (*i)->OnRender(renderContext); +} + +void EntityManager::OnResize() +{ + STACK_TRACE; + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + (*i)->OnResize(); +} + +void EntityManager::OnUpdate(float delta) +{ + STACK_TRACE; + // find any inactive components and remove the associated entities before + // we update anything + EntityList list; + GetAllWith(list); + for (EntityList::iterator i = list.begin(); i != list.end(); ++i) + Remove(*i); + + for (ComponentSystemList::iterator i = m_componentSystems.begin(); i != m_componentSystems.end(); ++i) + (*i)->OnUpdate(delta); +} diff --git a/src/entities/entitymanager.h b/src/entities/entitymanager.h new file mode 100644 index 0000000..21e9355 --- /dev/null +++ b/src/entities/entitymanager.h @@ -0,0 +1,321 @@ +#ifndef __ENTITIES_ENTITYMANAGER_H_INCLUDED__ +#define __ENTITIES_ENTITYMANAGER_H_INCLUDED__ + +#include "../framework/common.h" +#include "../framework/debug.h" + +#include +#include +#include + +#include "component.h" +#include "componentsystem.h" +#include "entitypreset.h" +#include "globalcomponent.h" + +class Entity; +class EventManager; +class RenderContext; + +typedef stl::list EntityList; +typedef stl::list ComponentList; +typedef stl::set EntitySet; +typedef stl::map EntityComponentsMap; +typedef stl::map ComponentStore; +typedef stl::list ComponentSystemList; +typedef stl::map EntityPresetMap; +typedef stl::map GlobalComponentStore; + +class EntityManager +{ +public: + EntityManager(EventManager *eventManager); + virtual ~EntityManager(); + + template T* AddSubsystem(); + template T* AddSubsystemBefore(); + template T* GetSubsystem() const; + template void RemoveSubsystem(); + void RemoveAllSubsystems(); + + template void AddPreset(); + template void RemovePreset(); + void RemoveAllPresets(); + + Entity* Add(); + template Entity* AddUsingPreset(EntityPresetArgs *args = NULL); + Entity* AddUsingPreset(ENTITYPRESET_TYPE type, EntityPresetArgs *args = NULL); + template Entity* GetWith() const; + template void GetAllWith(EntityList &matches) const; + template BOOL WasCreatedUsingPreset(Entity *entity) const; + BOOL WasCreatedUsingPreset(const Entity *entity, ENTITYPRESET_TYPE type) const; + void Remove(Entity *entity); + void RemoveAll(); + BOOL IsValid(const Entity *entity) const; + uint32_t GetNumEntities() const { return m_entities.size(); } + + template T* AddComponent(Entity *entity); + template T* GetComponent(const Entity *entity) const; + template void RemoveComponent(Entity *entity); + template BOOL HasComponent(const Entity *entity) const; + void GetAllComponentsFor(const Entity *entity, ComponentList &list) const; + + template T* AddGlobalComponent(); + template T* GetGlobalComponent() const; + template void RemoveGlobalComponent(); + template BOOL HasGlobalComponent() const; + void RemoveAllGlobalComponents(); + + void OnLostContext(); + void OnNewContext(); + void OnRender(RenderContext *renderContext); + void OnResize(); + void OnUpdate(float delta); + + EventManager* GetEventManager() const { return m_eventManager; } + +private: + void RemoveAllComponentsFrom(Entity *entity); + template ComponentSystemList::const_iterator FindSubsystem() const; + + EntitySet m_entities; + ComponentStore m_components; + GlobalComponentStore m_globalComponents; + ComponentSystemList m_componentSystems; + EntityPresetMap m_entityPresets; + EventManager *m_eventManager; +}; + +template +T* EntityManager::AddSubsystem() +{ + STACK_TRACE; + ASSERT(GetSubsystem() == NULL); + T* subsystem = new T(this, m_eventManager); + m_componentSystems.push_back(subsystem); + return subsystem; +} + +template +T* EntityManager::AddSubsystemBefore() +{ + STACK_TRACE; + ASSERT(GetSubsystem() == NULL); + ComponentSystemList::const_iterator i = FindSubsystem(); + ASSERT(i != m_componentSystems.end()); + T* subsystem = new T(this, m_eventManager); + m_componentSystems.insert(i, subsystem); + return subsystem; +} + +template +T* EntityManager::GetSubsystem() const +{ + STACK_TRACE; + ComponentSystemList::const_iterator i = FindSubsystem(); + if (i == m_componentSystems.end()) + return NULL; + else + return (*i)->As(); +} + +template +void EntityManager::RemoveSubsystem() +{ + STACK_TRACE; + ComponentSystemList::iterator i = FindSubsystem(); + if (i == m_componentSystems.end()) + return; + + SAFE_DELETE(*i); + m_componentSystems.erase(i); +} + +template +void EntityManager::AddPreset() +{ + STACK_TRACE; + T* preset = new T(this); + EntityPresetMap::const_iterator i = m_entityPresets.find(T::GetType()); + ASSERT(i == m_entityPresets.end()); + if (i != m_entityPresets.end()) + return; + + m_entityPresets[T::GetType()] = preset; +} + +template +void EntityManager::RemovePreset() +{ + STACK_TRACE; + EntityPresetMap::iterator i = m_entityPresets.find(T::GetType()); + if (i == m_entityPresets.end()) + return; + + EntityPreset *preset = i->second; + SAFE_DELETE(preset); + + m_entityPresets.erase(i); +} + +template +Entity* EntityManager::AddUsingPreset(EntityPresetArgs *args) +{ + STACK_TRACE; + return AddUsingPreset(T::GetType(), args); +} + +template +T* EntityManager::AddComponent(Entity *entity) +{ + STACK_TRACE; + ASSERT(GetComponent(entity) == NULL); + T* component = new T(); + m_components[T::GetType()].insert(EntityComponentsMap::value_type(entity, component)); + return component; +} + +template +T* EntityManager::GetComponent(const Entity *entity) const +{ + STACK_TRACE; + ComponentStore::const_iterator i = m_components.find(T::GetType()); + if (i == m_components.end()) + return NULL; + + const EntityComponentsMap &entitiesWithComponent = i->second; + EntityComponentsMap::const_iterator j = entitiesWithComponent.find(entity); + if (j == entitiesWithComponent.end()) + return NULL; + else + return j->second->As(); +} + +template +void EntityManager::RemoveComponent(Entity *entity) +{ + STACK_TRACE; + ComponentStore::iterator i = m_components.find(T::GetType()); + if (i == m_components.end()) + return; + + EntityComponentsMap &entitiesWithComponent = i->second; + EntityComponentsMap::iterator j = entitiesWithComponent.find(entity); + if (j == entitiesWithComponent.end()) + return; + else + { + SAFE_DELETE(j->second); + entitiesWithComponent.erase(entity); + } +} + +template +BOOL EntityManager::HasComponent(const Entity *entity) const +{ + STACK_TRACE; + ComponentStore::const_iterator i = m_components.find(T::GetType()); + if (i == m_components.end()) + return FALSE; + + const EntityComponentsMap &entitiesWithComponent = i->second; + EntityComponentsMap::const_iterator j = entitiesWithComponent.find(entity); + if (j == entitiesWithComponent.end()) + return FALSE; + else + return TRUE; +} + +template +T* EntityManager::AddGlobalComponent() +{ + STACK_TRACE; + ASSERT(GetGlobalComponent() == NULL); + T* newComponent = new T(); + m_globalComponents.insert(GlobalComponentStore::value_type(T::GetType(), newComponent)); + return newComponent; +} + +template +T* EntityManager::GetGlobalComponent() const +{ + STACK_TRACE; + GlobalComponentStore::const_iterator i = m_globalComponents.find(T::GetType()); + if (i == m_globalComponents.end()) + return NULL; + else + return i->second->As(); +} + +template +void EntityManager::RemoveGlobalComponent() +{ + GlobalComponentStore::iterator i = m_globalComponents.find(T::GetType()); + if (i == m_globalComponents.end()) + return; + + SAFE_DELETE(i->second); + m_globalComponents.erase(i); +} + +template +BOOL EntityManager::HasGlobalComponent() const +{ + STACK_TRACE; + GlobalComponentStore::const_iterator i = m_globalComponents.find(T::GetType()); + if (i == m_globalComponents.end()) + return FALSE; + else + return TRUE; +} + +template +Entity* EntityManager::GetWith() const +{ + ComponentStore::const_iterator i = m_components.find(T::GetType()); + if (i == m_components.end()) + return NULL; + + const EntityComponentsMap &entitiesWithComponent = i->second; + if (!entitiesWithComponent.empty()) + return (Entity*)entitiesWithComponent.begin()->first; + else + return NULL; +} + +template +void EntityManager::GetAllWith(EntityList &matches) const +{ + ComponentStore::const_iterator i = m_components.find(T::GetType()); + if (i == m_components.end()) + return; + + const EntityComponentsMap &entitiesWithComponent = i->second; + for (EntityComponentsMap::const_iterator j = entitiesWithComponent.begin(); j != entitiesWithComponent.end(); ++j) + matches.push_back((Entity*)j->first); +} + +template +BOOL EntityManager::WasCreatedUsingPreset(Entity *entity) const +{ + return WasCreatedUsingPreset(entity, T::GetType()); +} + +template +ComponentSystemList::const_iterator EntityManager::FindSubsystem() const +{ + ComponentSystemList::const_iterator i = m_componentSystems.begin(); + while (i != m_componentSystems.end()) + { + ComponentSystem *system = *i; + if (system->Is()) + return i; + + ++i; + } + + return i; +} + +#endif + diff --git a/src/entities/entitypreset.h b/src/entities/entitypreset.h new file mode 100644 index 0000000..2c7b261 --- /dev/null +++ b/src/entities/entitypreset.h @@ -0,0 +1,72 @@ +#ifndef __ENTITIES_ENTITYPRESET_H_INCLUDED__ +#define __ENTITIES_ENTITYPRESET_H_INCLUDED__ + +#include "../framework/common.h" +#include "entitypresetargs.h" + +typedef const char* ENTITYPRESET_TYPE; + +class Entity; +class EntityManager; + +class EntityPreset +{ +public: + EntityPreset(EntityManager *entityManager); + virtual ~EntityPreset(); + + virtual ENTITYPRESET_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(ENTITYPRESET_TYPE type) const; + template T* As(); + template const T* As() const; + + virtual Entity* Create(EntityPresetArgs *args = NULL) = 0; + +protected: + EntityManager* GetEntityManager() const { return m_entityManager; } + +private: + EntityManager *m_entityManager; +}; + +inline EntityPreset::EntityPreset(EntityManager *entityManager) +{ + m_entityManager = entityManager; +} + +inline EntityPreset::~EntityPreset() +{ +} + +template +inline BOOL EntityPreset::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL EntityPreset::Is(ENTITYPRESET_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* EntityPreset::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* EntityPreset::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif diff --git a/src/entities/entitypresetargs.h b/src/entities/entitypresetargs.h new file mode 100644 index 0000000..8382536 --- /dev/null +++ b/src/entities/entitypresetargs.h @@ -0,0 +1,47 @@ +#ifndef __ENTITIES_ENTITYPRESETARGS_H_INCLUDED__ +#define __ENTITIES_ENTITYPRESETARGS_H_INCLUDED__ + +#include "../framework/common.h" + +typedef const char* ENTITYPRESETARGS_TYPE; + +struct EntityPresetArgs +{ + virtual ENTITYPRESETARGS_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(ENTITYPRESETARGS_TYPE type) const; + template T* As(); + template const T* As() const; +}; + +template +inline BOOL EntityPresetArgs::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL EntityPresetArgs::Is(ENTITYPRESETARGS_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* EntityPresetArgs::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* EntityPresetArgs::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif diff --git a/src/entities/globalcomponent.h b/src/entities/globalcomponent.h new file mode 100644 index 0000000..7875407 --- /dev/null +++ b/src/entities/globalcomponent.h @@ -0,0 +1,60 @@ +#ifndef __ENTITIES_GLOBALCOMPONENT_H_INCLUDED__ +#define __ENTITIES_GLOBALCOMPONENT_H_INCLUDED__ + +#include "../framework/common.h" + +typedef const char* GLOBAL_COMPONENT_TYPE; + +class GlobalComponent +{ +public: + virtual ~GlobalComponent(); + virtual void Reset(); + + virtual GLOBAL_COMPONENT_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(GLOBAL_COMPONENT_TYPE type) const; + template T* As(); + template const T* As() const; +}; + +inline GlobalComponent::~GlobalComponent() +{ +} + +inline void GlobalComponent::Reset() +{ +} + +template +inline BOOL GlobalComponent::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL GlobalComponent::Is(GLOBAL_COMPONENT_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* GlobalComponent::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* GlobalComponent::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/events/event.h b/src/events/event.h new file mode 100644 index 0000000..0f8cb88 --- /dev/null +++ b/src/events/event.h @@ -0,0 +1,54 @@ +#ifndef __EVENTS_EVENT_H_INCLUDED__ +#define __EVENTS_EVENT_H_INCLUDED__ + +#include "../framework/common.h" + +typedef const char* EVENT_TYPE; + +const EVENT_TYPE EVENT_TYPE_WILDCARD = "EventWildcard"; + +struct Event +{ + virtual ~Event(); + virtual EVENT_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(EVENT_TYPE type) const; + template T* As(); + template const T* As() const; +}; + +inline Event::~Event() +{ +} + +template +inline BOOL Event::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL Event::Is(EVENT_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* Event::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* Event::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif diff --git a/src/events/eventlistener.h b/src/events/eventlistener.h new file mode 100644 index 0000000..365fb5c --- /dev/null +++ b/src/events/eventlistener.h @@ -0,0 +1,15 @@ +#ifndef __EVENTS_EVENTLISTENER_H_INCLUDED__ +#define __EVENTS_EVENTLISTENER_H_INCLUDED__ + +#include "../framework/common.h" + +struct Event; + +class EventListener +{ +public: + virtual BOOL Handle(const Event *event) = 0; +}; + +#endif + diff --git a/src/events/eventlistenerex.h b/src/events/eventlistenerex.h new file mode 100644 index 0000000..2512bb2 --- /dev/null +++ b/src/events/eventlistenerex.h @@ -0,0 +1,61 @@ +#ifndef __EVENTS_EVENTLISTENEREX_H_INCLUDED__ +#define __EVENTS_EVENTLISTENEREX_H_INCLUDED__ + +#include "../framework/common.h" +#include "eventlistener.h" +#include "eventmanager.h" + +struct Event; + +class EventListenerEx : public EventListener +{ +public: + EventListenerEx(EventManager *eventManager); + virtual ~EventListenerEx(); + + template BOOL ListenFor(); + template BOOL StopListeningFor(); + BOOL ListenFor(EVENT_TYPE type); + BOOL StopListeningFor(EVENT_TYPE type); + + virtual BOOL Handle(const Event *event) = 0; + + EventManager* GetEventManager() const { return m_eventManager; } + +private: + EventManager *m_eventManager; +}; + +inline EventListenerEx::EventListenerEx(EventManager *eventManager) +{ + m_eventManager = eventManager; +} + +inline EventListenerEx::~EventListenerEx() +{ +} + +template +inline BOOL EventListenerEx::ListenFor() +{ + return m_eventManager->AddListener(this); +} + +template +inline BOOL EventListenerEx::StopListeningFor() +{ + return m_eventManager->RemoveListener(this); +} + +inline BOOL EventListenerEx::ListenFor(EVENT_TYPE type) +{ + return m_eventManager->AddListener(this, type); +} + +inline BOOL EventListenerEx::StopListeningFor(EVENT_TYPE type) +{ + return m_eventManager->RemoveListener(this, type); +} + +#endif + diff --git a/src/events/eventlogger.cpp b/src/events/eventlogger.cpp new file mode 100644 index 0000000..747da2a --- /dev/null +++ b/src/events/eventlogger.cpp @@ -0,0 +1,25 @@ +#include "../framework/debug.h" +#include "../framework/log.h" + +#include "eventlogger.h" +#include "event.h" +#include "eventmanager.h" + +EventLogger::EventLogger(EventManager *eventManager) + : EventListener() +{ + STACK_TRACE; + eventManager->AddListener(this, EVENT_TYPE_WILDCARD); +} + +EventLogger::~EventLogger() +{ + STACK_TRACE; +} + +BOOL EventLogger::Handle(const Event *event) +{ + STACK_TRACE; + LOG_INFO("EVENTLOGGER", "Event \"%s\" occurred.\n", event->GetTypeOf()); + return FALSE; +} diff --git a/src/events/eventlogger.h b/src/events/eventlogger.h new file mode 100644 index 0000000..35fd901 --- /dev/null +++ b/src/events/eventlogger.h @@ -0,0 +1,19 @@ +#ifndef __EVENTS_EVENTLOGGER_H_INCLUDED__ +#define __EVENTS_EVENTLOGGER_H_INCLUDED__ + +#include "../framework/common.h" +#include "eventlistener.h" + +class EventManager; +struct Event; + +class EventLogger : public EventListener +{ +public: + EventLogger(EventManager *eventManager); + virtual ~EventLogger(); + + BOOL Handle(const Event *event); +}; + +#endif diff --git a/src/events/eventmanager.cpp b/src/events/eventmanager.cpp new file mode 100644 index 0000000..b7cc1c3 --- /dev/null +++ b/src/events/eventmanager.cpp @@ -0,0 +1,277 @@ +#include "../framework/debug.h" + +#include "eventmanager.h" +#include "event.h" +#include "eventlistener.h" + +EventManager::EventManager() +{ + STACK_TRACE; + m_activeQueue = 0; +} + +EventManager::~EventManager() +{ + STACK_TRACE; +} + +BOOL EventManager::AddListener(EventListener *listener, EVENT_TYPE type) +{ + STACK_TRACE; + // TODO: validate type + + EventListenerMap::iterator listenerItor = m_registry.find(type); + if (listenerItor == m_registry.end()) + { + // need to register this listener for the given type + EventListenerMapIRes result = m_registry.insert(EventListenerMapEnt(type, EventListenerTable())); + ASSERT(result.second != FALSE); + ASSERT(result.first != m_registry.end()); + + listenerItor = result.first; + } + + // prevent duplicate listeners from being registered + EventListenerTable &table = (*listenerItor).second; + for (EventListenerTable::iterator itor = table.begin(); itor != table.end(); ++itor) + { + ASSERT(*itor != listener); + } + + table.push_back(listener); + + // also update the list of currently registered event types + m_typeList.insert(type); + + return TRUE; +} + +BOOL EventManager::RemoveListener(EventListener *listener, EVENT_TYPE type) +{ + STACK_TRACE; + BOOL result = FALSE; + + // TODO: validate type + + // get the list of listeners for the given event type + EventListenerMap::iterator itor = m_registry.find(type); + if (itor == m_registry.end()) + return FALSE; + + // check this list for the specified listener + EventListenerTable &table = itor->second; + for (EventListenerTable::iterator j = table.begin(); j != table.end(); ++j) + { + if (*j == listener) + { + // found the listener + table.erase(j); + result = TRUE; + + // if there are no more listeners for this type, remove the type from the list of registered event types + if (table.size() == 0) + m_typeList.erase(type); + + // don't need to worry about duplicate listeners since AddListener() stops them from being added... + break; + } + } + + return result; +} + +BOOL EventManager::Trigger(const Event *event) const +{ + STACK_TRACE; + // TODO: validate type + + // trigger events for wildcard listeners first + EventListenerMap::const_iterator wildcardItor = m_registry.find(EVENT_TYPE_WILDCARD); + if (wildcardItor != m_registry.end()) + { + const EventListenerTable &table = wildcardItor->second; + for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) + { + EventListener *listener = *i; + listener->Handle(event); + } + } + + // find the listener list for the event type + EventListenerMap::const_iterator itor = m_registry.find(event->GetTypeOf()); + if (itor == m_registry.end()) + return FALSE; + + BOOL result = FALSE; + + // trigger the event in each listener + const EventListenerTable &table = itor->second; + for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) + { + EventListener *listener = *i; + if (listener->Handle(event)) + { + // only return TRUE if a listener signals they handled the event + result = TRUE; + } + } + + return result; +} + +BOOL EventManager::Queue(const Event *event) +{ + STACK_TRACE; + ASSERT(m_activeQueue >= 0); + ASSERT(m_activeQueue < NUM_EVENT_QUEUES); + + // TODO: validate type + + EventListenerMap::const_iterator itor = m_registry.find(event->GetTypeOf()); + if (itor == m_registry.end()) + { + // no specific listener for just this event's type... try a wildcard listener next + EventListenerMap::const_iterator wildcardItor = m_registry.find(EVENT_TYPE_WILDCARD); + if (wildcardItor == m_registry.end()) + { + // no wildcard listener either... useless event! + return FALSE; + } + } + + m_queues[m_activeQueue].push_back(event); + return TRUE; +} + +BOOL EventManager::Abort(EVENT_TYPE type, BOOL allOfType) +{ + STACK_TRACE; + ASSERT(m_activeQueue >= 0); + ASSERT(m_activeQueue < NUM_EVENT_QUEUES); + + // TODO: validate type + + EventListenerMap::iterator itor = m_registry.find(type); + if (itor == m_registry.end()) + return FALSE; // no listeners for this type + + BOOL result = FALSE; + + EventQueue &queue = m_queues[m_activeQueue]; + for (EventQueue::iterator i = queue.begin(); i != queue.end(); ++i) + { + const Event *event = *i; + if (event->GetTypeOf() == type) + { + // found a match, remove it from the queue + i = queue.erase(i); + result = TRUE; + + if (!allOfType) + break; + } + else + ++i; + } + + return result; +} + +BOOL EventManager::ProcessQueue() +{ + STACK_TRACE; + EventListenerMap::const_iterator wildcardItor = m_registry.find(EVENT_TYPE_WILDCARD); + + // swap active queues and empty the new queue + int queueToProcess = m_activeQueue; + m_activeQueue = (m_activeQueue + 1) % NUM_EVENT_QUEUES; + m_queues[m_activeQueue].clear(); + + // process the queue! + EventQueue &queue = m_queues[queueToProcess]; + while (queue.size() > 0) + { + // pop the next event off the queue + const Event *event = queue.front(); + queue.pop_front(); + + EVENT_TYPE type = event->GetTypeOf(); + + // process wildcard listeners first (if any) + if (wildcardItor != m_registry.end()) + { + const EventListenerTable &table = wildcardItor->second; + for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) + { + EventListener *listener = *i; + listener->Handle(event); + } + } + + EventListenerMap::const_iterator listenerItor = m_registry.find(type); + if (listenerItor != m_registry.end()) + { + const EventListenerTable &table = listenerItor->second; + for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) + { + EventListener *listener = *i; + if (listener->Handle(event)) + break; // don't let other listeners handle the event if this one signals it handled it + } + } + + SAFE_DELETE(event); + } + + // if there are any events left in the queue, push them onto the active queue + if (queue.size() != 0) + { + while (queue.size() > 0) + { + // to preserve sequencing, go bottom-up on the remainder of the queue that was processed + // inserting them at the head of the active queue + const Event *event = queue.back(); + queue.pop_back(); + m_queues[m_activeQueue].push_front(event); + } + + return FALSE; + } + else + return TRUE; +} + +EventListenerList EventManager::GetListenerList(EVENT_TYPE type) const +{ + STACK_TRACE; + EventListenerMap::const_iterator listenerItor = m_registry.find(type); + if (listenerItor == m_registry.end()) + return EventListenerList(); // no registered listeners for this type + + const EventListenerTable &table = listenerItor->second; + if (table.size() == 0) + return EventListenerList(); // no registered listeners for this type + + EventListenerList result; + result.reserve(table.size()); + + for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) + result.push_back(*i); + + return result; +} + +EventTypeList EventManager::GetTypeList() const +{ + STACK_TRACE; + if (m_typeList.size() == 0) + return EventTypeList(); // no types have been registered + + EventTypeList result; + result.reserve(m_typeList.size()); + + for (EventTypeSet::const_iterator i = m_typeList.begin(); i != m_typeList.end(); ++i) + result.push_back(*i); + + return result; +} diff --git a/src/events/eventmanager.h b/src/events/eventmanager.h new file mode 100644 index 0000000..3b1c734 --- /dev/null +++ b/src/events/eventmanager.h @@ -0,0 +1,82 @@ +#ifndef __EVENTS_EVENTMANAGER_H_INCLUDED__ +#define __EVENTS_EVENTMANAGER_H_INCLUDED__ + +#include "../framework/common.h" + +#include "event.h" + +#include +#include +#include +#include + +class EventListener; + +typedef stl::vector EventListenerList; +typedef stl::vector EventTypeList; + +const int NUM_EVENT_QUEUES = 2; + +class EventManager +{ +public: + EventManager(); + virtual ~EventManager(); + + template BOOL AddListener(EventListener *listener); + template BOOL RemoveListener(EventListener *listener); + BOOL AddListener(EventListener *listener, EVENT_TYPE type); + BOOL RemoveListener(EventListener *listener, EVENT_TYPE type); + + BOOL Trigger(const Event *event) const; + BOOL Queue(const Event *event); + template BOOL Abort(BOOL allOfType = FALSE); + BOOL Abort(EVENT_TYPE type, BOOL allOfType = FALSE); + + BOOL ProcessQueue(); + + template EventListenerList GetListenerList() const; + EventListenerList GetListenerList(EVENT_TYPE type) const; + EventTypeList GetTypeList() const; + +private: + typedef stl::set EventTypeSet; + typedef stl::pair EventTypeSetIRes; + typedef stl::list EventListenerTable; + typedef stl::map EventListenerMap; + typedef stl::pair EventListenerMapEnt; + typedef stl::pair EventListenerMapIRes; + typedef stl::list EventQueue; + + EventTypeSet m_typeList; + EventListenerMap m_registry; + EventQueue m_queues[NUM_EVENT_QUEUES]; + int m_activeQueue; +}; + +template +BOOL EventManager::AddListener(EventListener *listener) +{ + return AddListener(listener, T::GetType()); +} + +template +BOOL EventManager::RemoveListener(EventListener *listener) +{ + return RemoveListener(listener, T::GetType()); +} + +template +BOOL EventManager::Abort(BOOL allOfType) +{ + return Abort(T::GetType(), allOfType); +} + +template +EventListenerList EventManager::GetListenerList() const +{ + return GetListenerList(T::GetType()); +} + +#endif + diff --git a/src/framework/assets/animation/joint.h b/src/framework/assets/animation/joint.h new file mode 100644 index 0000000..760258d --- /dev/null +++ b/src/framework/assets/animation/joint.h @@ -0,0 +1,36 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_JOINT_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_JOINT_H_INCLUDED__ + +#include "../../common.h" +#include "jointkeyframe.h" +#include "../../math/matrix4x4.h" +#include + +const int32_t NO_JOINT = -1; + +struct Joint +{ + Joint(); + virtual ~Joint(); + + stl::string name; + Joint *parent; + int32_t parentIndex; + Matrix4x4 relative; + Matrix4x4 absolute; + JointKeyFrame *frames; +}; + +inline Joint::Joint() +{ + frames = NULL; + parent = NULL; + parentIndex = NO_JOINT; +} + +inline Joint::~Joint() +{ + SAFE_DELETE_ARRAY(frames); +} + +#endif diff --git a/src/framework/assets/animation/jointkeyframe.h b/src/framework/assets/animation/jointkeyframe.h new file mode 100644 index 0000000..7f1b6b0 --- /dev/null +++ b/src/framework/assets/animation/jointkeyframe.h @@ -0,0 +1,13 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_JOINTKEYFRAME_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_JOINTKEYFRAME_H_INCLUDED__ + +#include "../../math/quaternion.h" +#include "../../math/vector3.h" + +struct JointKeyFrame +{ + Vector3 position; + Quaternion rotation; +}; + +#endif diff --git a/src/framework/assets/animation/jointvertexmapping.h b/src/framework/assets/animation/jointvertexmapping.h new file mode 100644 index 0000000..f7257fb --- /dev/null +++ b/src/framework/assets/animation/jointvertexmapping.h @@ -0,0 +1,12 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_JOINTVERTEXMAPPING_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_JOINTVERTEXMAPPING_H_INCLUDED__ + +#include "../../common.h" + +struct JointVertexMapping +{ + int32_t jointIndex; + float weight; +}; + +#endif diff --git a/src/framework/assets/animation/keyframe.cpp b/src/framework/assets/animation/keyframe.cpp new file mode 100644 index 0000000..e94b565 --- /dev/null +++ b/src/framework/assets/animation/keyframe.cpp @@ -0,0 +1,35 @@ +#include "../../debug.h" + +#include "keyframe.h" + +#include "../../math/vector3.h" + +Keyframe::Keyframe(uint32_t numVertices) +{ + STACK_TRACE; + AllocateMemory(numVertices); +} + +Keyframe::Keyframe(const stl::string &name, uint32_t numVertices) +{ + STACK_TRACE; + m_name = name; + AllocateMemory(numVertices); +} + +void Keyframe::AllocateMemory(uint32_t numVertices) +{ + STACK_TRACE; + m_numVertices = numVertices; + m_vertices = new Vector3[m_numVertices]; + ASSERT(m_vertices != NULL); + m_normals = new Vector3[m_numVertices]; + ASSERT(m_normals != NULL); +} + +Keyframe::~Keyframe() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_vertices); + SAFE_DELETE_ARRAY(m_normals); +} diff --git a/src/framework/assets/animation/keyframe.h b/src/framework/assets/animation/keyframe.h new file mode 100644 index 0000000..3ca5541 --- /dev/null +++ b/src/framework/assets/animation/keyframe.h @@ -0,0 +1,59 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAME_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAME_H_INCLUDED__ + +#include "../../common.h" +#include + +struct Vector3; + +/** + * Holds vertex and normal information for a single keyframe. + */ +class Keyframe +{ +public: + /** + * Creates a new keyframe. + * @param numVertices the number of vertices in this keyframe + */ + Keyframe(uint32_t numVertices); + + /** + * Creates a new keyframe. + * @param name the unique name for this keyframe + * @param numVertices the number of vertices in this keyframe + */ + Keyframe(const stl::string &name, uint32_t numVertices); + + virtual ~Keyframe(); + + /** + * @return the unique name of this keyframe + */ + const stl::string& GetName() const { return m_name; } + + /** + * @return the number of vertices in this keyframe + */ + uint32_t GetNumVertices() const { return m_numVertices; } + + /** + * @return pointer to the vertices in this keyframe + */ + Vector3* GetVertices() { return m_vertices; } + + /** + * @return pointer to the normals in this keyframe + */ + Vector3* GetNormals() { return m_normals; } + +private: + void AllocateMemory(uint32_t numVertices); + + stl::string m_name; + uint32_t m_numVertices; + Vector3 *m_vertices; + Vector3 *m_normals; +}; + +#endif diff --git a/src/framework/assets/animation/keyframemesh.cpp b/src/framework/assets/animation/keyframemesh.cpp new file mode 100644 index 0000000..32db08b --- /dev/null +++ b/src/framework/assets/animation/keyframemesh.cpp @@ -0,0 +1,85 @@ +#include "../../debug.h" + +#include "keyframemesh.h" +#include "keyframe.h" +#include "keyframemeshfile.h" +#include "keyframemeshtriangle.h" +#include "../../graphics/vertexbuffer.h" +#include "../../math/vector2.h" +#include "../../math/vector3.h" +#include "../../support/animationsequence.h" + +#include + +KeyframeMesh::KeyframeMesh(const KeyframeMeshFile *file) + : Content() +{ + STACK_TRACE; + m_numFrames = file->GetNumFrames(); + m_frames = new Keyframe*[m_numFrames]; + ASSERT(m_frames != NULL); + for (uint32_t i = 0; i < m_numFrames; ++i) + { + Keyframe *srcFrame = file->GetFrames()[i]; + uint32_t numVertices = srcFrame->GetNumVertices(); + + Keyframe *frame = new Keyframe(srcFrame->GetName(), numVertices); + ASSERT(frame != NULL); + memcpy(frame->GetVertices(), srcFrame->GetVertices(), sizeof(Vector3) * numVertices); + memcpy(frame->GetNormals(), srcFrame->GetNormals(), sizeof(Vector3) * numVertices); + + m_frames[i] = frame; + } + + m_numTexCoords = file->GetNumTexCoords(); + m_texCoords = new Vector2[m_numTexCoords]; + ASSERT(m_texCoords != NULL); + memcpy(m_texCoords, file->GetTexCoords(), sizeof(Vector2) * m_numTexCoords); + + m_numTriangles = file->GetNumTriangles(); + m_triangles = new KeyframeMeshTriangle[m_numTriangles]; + ASSERT(m_triangles != NULL); + memcpy(m_triangles, file->GetTriangles(), sizeof(KeyframeMeshTriangle) * m_numTriangles); + + AnimationList::iterator itor; + AnimationList srcAnimations = file->GetAnimations(); + for (itor = srcAnimations.begin(); itor != srcAnimations.end(); ++itor) + { + AnimationSequence sequence; + sequence.start = itor->second.start; + sequence.stop = itor->second.stop; + m_animations[itor->first] = sequence; + } + + m_numVerticesPerFrame = file->GetNumVerticesPerFrame(); + + m_vertices = new VertexBuffer(BUFFEROBJECT_USAGE_STREAM); + ASSERT(m_vertices != NULL); + m_vertices->AddAttribute(ATTRIB_SIZE_VEC3); // position for frame 1 + m_vertices->AddAttribute(ATTRIB_SIZE_VEC3); // position for frame 2 + m_vertices->AddAttribute(ATTRIB_SIZE_VEC3); // normal for frame 1 + m_vertices->AddAttribute(ATTRIB_SIZE_VEC3); // normal for frame 2 + m_vertices->AddAttribute(VERTEX_TEXCOORD); + m_vertices->Create(m_numVerticesPerFrame); +} + +KeyframeMesh::~KeyframeMesh() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_numFrames; ++i) + SAFE_DELETE(m_frames[i]); + SAFE_DELETE_ARRAY(m_frames); + SAFE_DELETE_ARRAY(m_texCoords); + SAFE_DELETE_ARRAY(m_triangles); + SAFE_DELETE(m_vertices); +} + +const AnimationSequence* KeyframeMesh::GetAnimation(const stl::string &name) const +{ + STACK_TRACE; + AnimationList::const_iterator itor = m_animations.find(name); + if (itor != m_animations.end()) + return &itor->second; + else + return NULL; +} \ No newline at end of file diff --git a/src/framework/assets/animation/keyframemesh.h b/src/framework/assets/animation/keyframemesh.h new file mode 100644 index 0000000..3e29e50 --- /dev/null +++ b/src/framework/assets/animation/keyframemesh.h @@ -0,0 +1,101 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESH_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESH_H_INCLUDED__ + +#include "../../common.h" +#include +#include "../../support/animationsequence.h" +#include "../../content/content.h" + +class Keyframe; +class KeyframeMeshFile; +struct KeyframeMeshTriangle; +struct Vector2; +class VertexBuffer; + +/** + * Keyframe mesh object containing geometry that is animated via + * interpolation of vertices contained in keyframes. + */ +class KeyframeMesh : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "KeyframeMesh"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + /** + * Creates a keyframe mesh object. + * @param file the keyframe mesh file to load the mesh data from + */ + KeyframeMesh(const KeyframeMeshFile *file); + + virtual ~KeyframeMesh(); + + /** + * @return the total number of keyframes contained in this mesh + */ + uint32_t GetNumFrames() const { return m_numFrames; } + + /** + * @return pointer to the mesh's keyframes + */ + Keyframe** GetFrames() const { return m_frames; } + + /** + * @return the total number of texture coordinates contained in this mesh + */ + uint32_t GetNumTexCoords() const { return m_numTexCoords; } + + /** + * @return pointer to the mesh's texture coordinates + */ + Vector2* GetTexCoords() const { return m_texCoords; } + + /** + * @return the total number of triangles contained in this mesh + */ + uint32_t GetNumTriangles() const { return m_numTriangles; } + + /** + * @return pointer to the mesh's triangles + */ + KeyframeMeshTriangle* GetTriangles() const { return m_triangles; } + + /** + * @return the number of vertices per keyframe in this mesh + */ + uint32_t GetNumVerticesPerFrame() const { return m_numVerticesPerFrame; } + + /** + * Retrieves an animation sequence. + * @param name the name of the sequence to retrieve + * @return the matching sequence or NULL if one was not found + */ + const AnimationSequence* GetAnimation(const stl::string &name) const; + + /** + * @return a list of all of this mesh's the animation sequences. + */ + const AnimationList* GetAnimations() const { return &m_animations; } + + /** + * @return the mesh's vertex buffer + */ + VertexBuffer* GetVertices() const { return m_vertices; } + +private: + uint32_t m_numFrames; + Keyframe **m_frames; + uint32_t m_numTexCoords; + Vector2 *m_texCoords; + uint32_t m_numTriangles; + KeyframeMeshTriangle *m_triangles; + AnimationList m_animations; + uint32_t m_numVerticesPerFrame; + VertexBuffer *m_vertices; +}; + +#endif diff --git a/src/framework/assets/animation/keyframemeshfile.cpp b/src/framework/assets/animation/keyframemeshfile.cpp new file mode 100644 index 0000000..9e926ef --- /dev/null +++ b/src/framework/assets/animation/keyframemeshfile.cpp @@ -0,0 +1,130 @@ +#include "../../debug.h" + +#include "keyframemeshfile.h" + +#include "keyframe.h" +#include "keyframemeshtriangle.h" +#include "../meshfile.h" +#include "../../file/file.h" +#include "../../math/vector2.h" +#include "../../math/vector3.h" +#include "../../support/animationsequence.h" + +KeyframeMeshFile::KeyframeMeshFile(File *file) + : MeshFile(file) +{ + STACK_TRACE; + m_numFrames = 0; + m_numTexCoords = 0; + m_numTriangles = 0; + m_numVerticesPerFrame = 0; + m_frames = NULL; + m_texCoords = NULL; + m_triangles = NULL; + Load(); +} + +KeyframeMeshFile::~KeyframeMeshFile() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_numFrames; ++i) + SAFE_DELETE(m_frames[i]); + SAFE_DELETE_ARRAY(m_frames); + SAFE_DELETE_ARRAY(m_texCoords); + SAFE_DELETE_ARRAY(m_triangles); + m_animations.clear(); +} + +void KeyframeMeshFile::Load() +{ + STACK_TRACE; + ChunkDescriptor *keyframesDesc = GetChunkDesc("KFR"); + ChunkDescriptor *texCoordsDesc = GetChunkDesc("TXT"); + ChunkDescriptor *trianglesDesc = GetChunkDesc("KTR"); + ChunkDescriptor *animationsDesc = GetChunkDesc("ANI"); + ASSERT(keyframesDesc != NULL); + ASSERT(texCoordsDesc != NULL); + ASSERT(trianglesDesc != NULL); + + File *file = GetFile(); + + // keyframes + file->Seek(keyframesDesc->start, FILESEEK_BEGINNING); + m_numFrames = file->ReadInt(); + uint32_t numVertices = file->ReadInt(); + m_frames = new Keyframe*[m_numFrames]; + ASSERT(m_frames != NULL); + for (uint32_t i = 0; i < m_numFrames; ++i) + { + Keyframe *frame = new Keyframe(numVertices); + ASSERT(frame != NULL); + Vector3 *vertices = frame->GetVertices(); + Vector3 *normals = frame->GetNormals(); + + // vertices + for (uint32_t j = 0; j < numVertices; ++j) + { + vertices[j].x = file->ReadFloat(); + vertices[j].y = file->ReadFloat(); + vertices[j].z = file->ReadFloat(); + } + + // normals + for (uint32_t j = 0; j < numVertices; ++j) + { + normals[j].x = file->ReadFloat(); + normals[j].y = file->ReadFloat(); + normals[j].z = file->ReadFloat(); + } + + m_frames[i] = frame; + } + + // texture coordinates + file->Seek(texCoordsDesc->start, FILESEEK_BEGINNING); + m_numTexCoords = file->ReadInt(); + m_texCoords = new Vector2[m_numTexCoords]; + ASSERT(m_texCoords != NULL); + for (uint32_t i = 0; i < m_numTexCoords; ++i) + { + m_texCoords[i].x = file->ReadFloat(); + m_texCoords[i].y = file->ReadFloat(); + } + + // triangles + file->Seek(trianglesDesc->start, FILESEEK_BEGINNING); + m_numTriangles = file->ReadInt(); + m_triangles = new KeyframeMeshTriangle[m_numTriangles]; + ASSERT(m_triangles != NULL); + for (uint32_t i = 0; i < m_numTriangles; ++i) + { + m_triangles[i].vertices[0] = file->ReadInt(); + m_triangles[i].vertices[1] = file->ReadInt(); + m_triangles[i].vertices[2] = file->ReadInt(); + + m_triangles[i].textureCoords[0] = file->ReadInt(); + m_triangles[i].textureCoords[1] = file->ReadInt(); + m_triangles[i].textureCoords[2] = file->ReadInt(); + } + + // for the rendering loop + m_numVerticesPerFrame = m_numTriangles * 3; + + // animations + if (animationsDesc != NULL) + { + file->Seek(animationsDesc->start, FILESEEK_BEGINNING); + uint32_t numAnimations = file->ReadInt(); + for (uint32_t i = 0; i < numAnimations; ++i) + { + AnimationSequence sequence; + stl::string name; + + file->ReadString(name); + sequence.start = file->ReadInt(); + sequence.stop = file->ReadInt(); + + m_animations[name] = sequence; + } + } +} diff --git a/src/framework/assets/animation/keyframemeshfile.h b/src/framework/assets/animation/keyframemeshfile.h new file mode 100644 index 0000000..082600d --- /dev/null +++ b/src/framework/assets/animation/keyframemeshfile.h @@ -0,0 +1,82 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHFILE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHFILE_H_INCLUDED__ + +#include "../../common.h" +#include +#include "../meshfile.h" +#include "../../support/animationsequence.h" + +class File; +class Keyframe; +struct KeyframeMeshTriangle; +struct Vector2; + +/** + * A keyframe mesh file which is loaded using a custom "chunked" file format. + */ +class KeyframeMeshFile : public MeshFile +{ +public: + /** + * Creates a keyframe mesh file object by loading the mesh information + * from the provided file. + * @param file the file that will be loaded as a keyframe mesh + */ + KeyframeMeshFile(File *file); + + virtual ~KeyframeMeshFile(); + + /** + * @return the total number of keyframes this mesh contains + */ + uint32_t GetNumFrames() const { return m_numFrames; } + + /** + * @return pointer to the mesh's keyframes + */ + Keyframe** GetFrames() const { return m_frames; } + + /** + * @return the total number of texture coordinates this mesh contains + */ + uint32_t GetNumTexCoords() const { return m_numTexCoords; } + + /** + * @return pointer to the mesh's texture coordinates + */ + Vector2* GetTexCoords() const { return m_texCoords; } + + /** + * @return the total number of triangles this mesh contains + */ + uint32_t GetNumTriangles() const { return m_numTriangles; } + + /** + * @return pointer to the mesh's triangles + */ + KeyframeMeshTriangle* GetTriangles() const { return m_triangles; } + + /** + * @return the mesh's animation sequences + */ + const AnimationList& GetAnimations() const { return m_animations; } + + /** + * @return the number of vertices each keyframe contains + */ + uint32_t GetNumVerticesPerFrame() const { return m_numVerticesPerFrame; } + +private: + void Load(); + + uint32_t m_numFrames; + Keyframe **m_frames; + uint32_t m_numTexCoords; + Vector2 *m_texCoords; + uint32_t m_numTriangles; + KeyframeMeshTriangle *m_triangles; + AnimationList m_animations; + uint32_t m_numVerticesPerFrame; +}; + +#endif diff --git a/src/framework/assets/animation/keyframemeshinstance.cpp b/src/framework/assets/animation/keyframemeshinstance.cpp new file mode 100644 index 0000000..9402fee --- /dev/null +++ b/src/framework/assets/animation/keyframemeshinstance.cpp @@ -0,0 +1,127 @@ +#include "../../debug.h" + +#include "keyframemeshinstance.h" + +#include "keyframemesh.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/texture.h" +#include "../../support/animationsequence.h" +#include + +KeyframeMeshInstance::KeyframeMeshInstance(KeyframeMesh *mesh) +{ + STACK_TRACE; + m_mesh = mesh; + m_texture = NULL; + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + + m_currentSequenceStart = 0; + m_currentSequenceEnd = 0; + m_currentSequenceLoop = FALSE; + m_thisFrame = 0; + m_nextFrame = 0; + m_interpolation = 0.0f; + m_isRunningTempSequence = FALSE; + m_oldSequenceLoop = FALSE; +} + +KeyframeMeshInstance::~KeyframeMeshInstance() +{ + STACK_TRACE; + SAFE_DELETE(m_renderState); +} + +void KeyframeMeshInstance::OnUpdate(float delta) +{ + STACK_TRACE; + if (m_currentSequenceStart != m_currentSequenceEnd) + { + m_interpolation += delta * 10; + if (m_interpolation >= 1.0f) + { + m_interpolation = 0.0f; + + ++m_thisFrame; + if (m_thisFrame > m_currentSequenceEnd) + { + m_thisFrame = m_currentSequenceStart; + + if (m_isRunningTempSequence) + { + RecoverFromTempSequence(); + return; + } + if (!m_currentSequenceLoop) + { + m_currentSequenceStart = m_currentSequenceEnd; + m_thisFrame = m_currentSequenceEnd; + m_nextFrame = m_thisFrame; + return; + } + } + + ++m_nextFrame; + if (m_nextFrame > m_currentSequenceEnd) + { + if (!m_currentSequenceLoop) + m_nextFrame = m_currentSequenceEnd; + else + m_nextFrame = m_currentSequenceStart; + } + } + } +} + +void KeyframeMeshInstance::SetSequence(uint32_t startFrame, uint32_t endFrame, BOOL loop) +{ + STACK_TRACE; + m_currentSequenceName.clear(); + m_currentSequenceStart = startFrame; + m_currentSequenceEnd = endFrame; + m_currentSequenceLoop = loop; + + m_thisFrame = m_currentSequenceStart; + m_nextFrame = m_thisFrame + 1; + if (m_nextFrame > m_currentSequenceEnd) + m_nextFrame = m_currentSequenceEnd; + + m_interpolation = 0.0f; +} + +void KeyframeMeshInstance::SetSequence(const stl::string &name, BOOL loop) +{ + STACK_TRACE; + if (m_currentSequenceName == name) + return; + + const AnimationSequence *sequence = GetMesh()->GetAnimation(name); + ASSERT(sequence != NULL); + SetSequence(sequence->start, sequence->stop, loop); + m_currentSequenceName = name; +} + +void KeyframeMeshInstance::RunSequenceOnce(const stl::string &name) +{ + STACK_TRACE; + if (m_isRunningTempSequence) + return; + + m_oldSequenceName = m_currentSequenceName; + m_oldSequenceLoop = m_currentSequenceLoop; + + m_isRunningTempSequence = TRUE; + + SetSequence(name, FALSE); +} + +void KeyframeMeshInstance::RecoverFromTempSequence() +{ + STACK_TRACE; + m_isRunningTempSequence = FALSE; + SetSequence(m_oldSequenceName, m_oldSequenceLoop); + m_oldSequenceName.clear(); + m_oldSequenceLoop = false; +} + diff --git a/src/framework/assets/animation/keyframemeshinstance.h b/src/framework/assets/animation/keyframemeshinstance.h new file mode 100644 index 0000000..48aec1f --- /dev/null +++ b/src/framework/assets/animation/keyframemeshinstance.h @@ -0,0 +1,112 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHINSTANCE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHINSTANCE_H_INCLUDED__ + +#include "../../common.h" +#include + +class KeyframeMesh; +class RenderState; +class Texture; + +/** + * An instance of a keyframe mesh that can be manipulated and rendered from + * a single shared mesh object. + */ +class KeyframeMeshInstance +{ +public: + /** + * Creates a new keyframe mesh instance. + * @param mesh the mesh this instance is of + */ + KeyframeMeshInstance(KeyframeMesh *mesh); + + virtual ~KeyframeMeshInstance(); + + /** + * Update (tick) callback. + * @param delta time since last update + */ + void OnUpdate(float delta); + + /** + * Sets the current animation sequence. + * @param startFrame the first frame of the sequence + * @param endFrame the last frame of the sequence + * @param loop TRUE to loop the sequence, FALSE to stop when done + * and leave the current frame as the end frame + */ + void SetSequence(uint32_t startFrame, uint32_t endFrame, BOOL loop); + + /** + * Sets the current animation sequence. + * @param name the name of the sequence from the mesh's list of sequences + * @param loop TRUE to loop the sequence, FALSE to stop when done + * and leave the current frame as the end frame + */ + void SetSequence(const stl::string &name, BOOL loop); + + /** + * Temporarily override the current animation sequence to run the specified + * sequence just once. When it's finished, the original sequence will be + * restored and continued as before. + * @param name the name of the sequence from the mesh's list of sequences + */ + void RunSequenceOnce(const stl::string &name); + + /** + * @return the current frame + */ + uint32_t GetCurrentFrame() const { return m_thisFrame; } + + /** + * @return the next frame + */ + uint32_t GetNextFrame() const { return m_nextFrame; } + + /** + * @return the current interpolation amount between the current frame + * and the next frame + */ + float GetInterpolation() const { return m_interpolation; } + + /** + * @return the current texture + */ + Texture* GetTexture() const { return m_texture; } + + /** + * @param texture the new texture, or NULL to set no texture + */ + void SetTexture(Texture *texture) { m_texture = texture; } + + /** + * @return the render state used to render this instance + */ + RenderState* GetRenderState() const { return m_renderState; } + + /** + * @return the mesh this instance is of + */ + KeyframeMesh* GetMesh() const { return m_mesh; } + +private: + void RecoverFromTempSequence(); + + KeyframeMesh *m_mesh; + Texture *m_texture; + RenderState *m_renderState; + stl::string m_currentSequenceName; + uint32_t m_currentSequenceStart; + uint32_t m_currentSequenceEnd; + BOOL m_currentSequenceLoop; + uint32_t m_thisFrame; + uint32_t m_nextFrame; + float m_interpolation; + BOOL m_isRunningTempSequence; + stl::string m_oldSequenceName; + BOOL m_oldSequenceLoop; +}; + +#endif + diff --git a/src/framework/assets/animation/keyframemeshrenderer.cpp b/src/framework/assets/animation/keyframemeshrenderer.cpp new file mode 100644 index 0000000..78c902e --- /dev/null +++ b/src/framework/assets/animation/keyframemeshrenderer.cpp @@ -0,0 +1,154 @@ +#include "../../debug.h" + +#include "keyframemeshrenderer.h" + +#include "keyframe.h" +#include "keyframemesh.h" +#include "keyframemeshinstance.h" +#include "keyframemeshtriangle.h" +#include "../../graphics/graphicsdevice.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/texture.h" +#include "../../graphics/vertexbuffer.h" +#include "../../graphics/vertexlerpshader.h" +#include "../../math/vector3.h" + +KeyframeMeshRenderer::KeyframeMeshRenderer() +{ + STACK_TRACE; +} + +KeyframeMeshRenderer::~KeyframeMeshRenderer() +{ + STACK_TRACE; +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + instance->GetRenderState()->Apply(); + Render(graphicsDevice, instance->GetMesh(), instance->GetTexture(), instance->GetCurrentFrame(), instance->GetNextFrame(), instance->GetInterpolation(), shader); +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, uint32_t frame, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + instance->GetRenderState()->Apply(); + Render(graphicsDevice, instance->GetMesh(), instance->GetTexture(), frame, shader); +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + instance->GetRenderState()->Apply(); + Render(graphicsDevice, instance->GetMesh(), instance->GetTexture(), instance->GetCurrentFrame(), instance->GetNextFrame(), instance->GetInterpolation(), shader); +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + Render(graphicsDevice, mesh, texture, 0, shader); +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, uint32_t frame, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + SetFrameVertices(mesh, frame); + + if (texture != NULL) + graphicsDevice->BindTexture(texture); + + shader->SetLerp(0.0f); + + graphicsDevice->BindVertexBuffer(mesh->GetVertices()); + graphicsDevice->RenderTriangles(); + graphicsDevice->UnbindVertexBuffer(); +} + +void KeyframeMeshRenderer::Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexLerpShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + SetFrameVertices(mesh, startFrame, endFrame); + + if (texture != NULL) + graphicsDevice->BindTexture(texture); + + shader->SetLerp(interpolation); + + graphicsDevice->BindVertexBuffer(mesh->GetVertices()); + graphicsDevice->RenderTriangles(); + graphicsDevice->UnbindVertexBuffer(); +} + +void KeyframeMeshRenderer::SetFrameVertices(KeyframeMesh *mesh, uint32_t frame) +{ + STACK_TRACE; + int pos; + Keyframe *keyframe = mesh->GetFrames()[frame]; + KeyframeMeshTriangle *triangle; + VertexBuffer *vertices = mesh->GetVertices(); + + for (uint32_t i = 0; i < mesh->GetNumTriangles(); ++i) + { + pos = i * 3; + triangle = &mesh->GetTriangles()[i]; + + vertices->Set3f(0, pos, keyframe->GetVertices()[triangle->vertices[0]]); + vertices->Set3f(1, pos, ZERO_VECTOR); + vertices->Set3f(2, pos, keyframe->GetNormals()[triangle->vertices[0]]); + vertices->Set3f(3, pos, ZERO_VECTOR); + vertices->Set2f(4, pos, mesh->GetTexCoords()[triangle->textureCoords[0]]); + + vertices->Set3f(0, pos + 1, keyframe->GetVertices()[triangle->vertices[1]]); + vertices->Set3f(1, pos + 1, ZERO_VECTOR); + vertices->Set3f(2, pos + 1, keyframe->GetNormals()[triangle->vertices[1]]); + vertices->Set3f(3, pos + 2, ZERO_VECTOR); + vertices->Set2f(4, pos + 1, mesh->GetTexCoords()[triangle->textureCoords[1]]); + + vertices->Set3f(0, pos + 2, keyframe->GetVertices()[triangle->vertices[2]]); + vertices->Set3f(1, pos + 2, ZERO_VECTOR); + vertices->Set3f(2, pos + 2, keyframe->GetNormals()[triangle->vertices[2]]); + vertices->Set3f(3, pos + 2, ZERO_VECTOR); + vertices->Set2f(4, pos + 2, mesh->GetTexCoords()[triangle->textureCoords[2]]); + } +} + +void KeyframeMeshRenderer::SetFrameVertices(KeyframeMesh *mesh, uint32_t startFrame, uint32_t endFrame) +{ + STACK_TRACE; + uint32_t pos; + Keyframe *frame1 = mesh->GetFrames()[startFrame]; + Keyframe *frame2 = mesh->GetFrames()[endFrame]; + KeyframeMeshTriangle *triangle; + VertexBuffer *vertices = mesh->GetVertices(); + + for (uint32_t i = 0; i < mesh->GetNumTriangles(); ++i) + { + pos = i * 3; + triangle = &mesh->GetTriangles()[i]; + + vertices->Set3f(0, pos, frame1->GetVertices()[triangle->vertices[0]]); + vertices->Set3f(1, pos, frame2->GetVertices()[triangle->vertices[0]]); + vertices->Set3f(2, pos, frame1->GetNormals()[triangle->vertices[0]]); + vertices->Set3f(3, pos, frame2->GetNormals()[triangle->vertices[0]]); + vertices->Set2f(4, pos, mesh->GetTexCoords()[triangle->textureCoords[0]]); + + vertices->Set3f(0, pos + 1, frame1->GetVertices()[triangle->vertices[1]]); + vertices->Set3f(1, pos + 1, frame2->GetVertices()[triangle->vertices[1]]); + vertices->Set3f(2, pos + 1, frame1->GetNormals()[triangle->vertices[1]]); + vertices->Set3f(3, pos + 1, frame2->GetNormals()[triangle->vertices[1]]); + vertices->Set2f(4, pos + 1, mesh->GetTexCoords()[triangle->textureCoords[1]]); + + vertices->Set3f(0, pos + 2, frame1->GetVertices()[triangle->vertices[2]]); + vertices->Set3f(1, pos + 2, frame2->GetVertices()[triangle->vertices[2]]); + vertices->Set3f(2, pos + 2, frame1->GetNormals()[triangle->vertices[2]]); + vertices->Set3f(3, pos + 2, frame2->GetNormals()[triangle->vertices[2]]); + vertices->Set2f(4, pos + 2, mesh->GetTexCoords()[triangle->textureCoords[2]]); + } +} diff --git a/src/framework/assets/animation/keyframemeshrenderer.h b/src/framework/assets/animation/keyframemeshrenderer.h new file mode 100644 index 0000000..415a044 --- /dev/null +++ b/src/framework/assets/animation/keyframemeshrenderer.h @@ -0,0 +1,88 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHRENDERER_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHRENDERER_H_INCLUDED__ + +#include "../../common.h" + +class GraphicsDevice; +class KeyframeMesh; +class KeyframeMeshInstance; +class Texture; +class VertexLerpShader; + +/** + * Helper object that renders instances of keyframe mesh objects and + * standalone keyframe mesh objects. + */ +class KeyframeMeshRenderer +{ +public: + /** + * Creates a keyframe mesh renderer. + */ + KeyframeMeshRenderer(); + + virtual ~KeyframeMeshRenderer(); + + /** + * Renders an instance of a keyframe mesh. + * @param graphicsDevice the graphics device to render with + * @param instance the keyframe mesh instance to render + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, VertexLerpShader *shader); + + /** + * Renders an instance of a keyframe mesh. + * @param graphicsDevice the graphics device to render with + * @param instance the keyframe mesh instance to render + * @param frame render this frame instead of the instance's current frame + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, uint32_t frame, VertexLerpShader *shader); + + /** + * Renders an instance of a keyframe mesh. + * @param graphicsDevice the graphics device to render with + * @param instance the keyframe mesh instance to render + * @param startFrame the start frame to use for rendering instead of + * the instance's current "current frame" + * @param endFrame the end frame to use for rendering instead of the + * instance's current "next frame" + * @param interpolation the amount to interpolate between the start frame + * and end frame + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMeshInstance *instance, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexLerpShader *shader); + + /** + * Renders a keyframe mesh using the first frame. + * @param graphicsDevice the graphics device to render with + * @param mesh the keyframe mesh to render + * @param texture the texture to render the mesh with, or NULL for no texture + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, VertexLerpShader *shader); + + /** + * Renders a keyframe mesh. + * @param graphicsDevice the graphics device to render with + * @param mesh the keyframe mesh to render + * @param texture the texture to render the mesh with, or NULL for no texture + * @param frame the keyframe to render + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, uint32_t frame, VertexLerpShader *shader); + + /** + * Renders a keyframe mesh. + * @param graphicsDevice the graphics device to render with + * @param mesh the keyframe mesh to render + * @param texture the texture to render the mesh with, or NULL for no texture + * @param startFrame the start frame to use for rendering + * @param endFrame the end frame to use for rendering + * @param interpolation the amount to interpolate by between the start + * and end frame + */ + void Render(GraphicsDevice *graphicsDevice, KeyframeMesh *mesh, const Texture *texture, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexLerpShader *shader); + +private: + void SetFrameVertices(KeyframeMesh *mesh, uint32_t frame); + void SetFrameVertices(KeyframeMesh *mesh, uint32_t startFrame, uint32_t endFrame); +}; + +#endif diff --git a/src/framework/assets/animation/keyframemeshtriangle.h b/src/framework/assets/animation/keyframemeshtriangle.h new file mode 100644 index 0000000..bd416d2 --- /dev/null +++ b/src/framework/assets/animation/keyframemeshtriangle.h @@ -0,0 +1,16 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHTRIANGLE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_KEYFRAMEMESHTRIANGLE_H_INCLUDED__ + +#include "../../common.h" + +/** + * Contains vertex and texture coordinate indices for a triangle in a + * keyframe mesh. + */ +struct KeyframeMeshTriangle +{ + uint32_t vertices[3]; + uint32_t textureCoords[3]; +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmesh.cpp b/src/framework/assets/animation/skeletalmesh.cpp new file mode 100644 index 0000000..1cf4b80 --- /dev/null +++ b/src/framework/assets/animation/skeletalmesh.cpp @@ -0,0 +1,141 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "skeletalmesh.h" +#include "joint.h" +#include "jointkeyframe.h" +#include "jointvertexmapping.h" +#include "skeletalmeshsubset.h" +#include "skeletalmeshtriangle.h" +#include "../../graphics/indexbuffer.h" +#include "../../graphics/vertexbuffer.h" +#include "../../math/matrix4x4.h" +#include "../../math/quaternion.h" +#include "../../math/vector3.h" +#include "../../support/animationsequence.h" + +SkeletalMesh::SkeletalMesh() +{ + STACK_TRACE; + m_numVertices = 0; + m_numSubsets = 0; + m_numJoints = 0; + m_numFrames = 0; + m_vertices = NULL; + m_jointMappings = NULL; + m_subsets = NULL; + m_joints = NULL; + m_rootJointIndex = NO_JOINT; + m_vertexBuffer = NULL; +} + +SkeletalMesh::~SkeletalMesh() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_joints); + SAFE_DELETE_ARRAY(m_jointMappings); + SAFE_DELETE_ARRAY(m_vertices); + SAFE_DELETE(m_vertexBuffer); + SAFE_DELETE_ARRAY(m_subsets); + m_animations.clear(); +} + +int32_t SkeletalMesh::GetIndexOfSubset(const stl::string &name) const +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_numSubsets; ++i) + { + if (m_subsets[i].GetName() == name) + return (int32_t)i; + } + + return -1; +} + +Joint* SkeletalMesh::GetJoint(const stl::string &name) const +{ + STACK_TRACE; + int32_t jointIndex = GetIndexOfJoint(name); + if (jointIndex == NO_JOINT) + return NULL; + else + return &m_joints[jointIndex]; +} + +int32_t SkeletalMesh::GetIndexOfJoint(const stl::string &name) const +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_numJoints; ++i) + { + if (m_joints[i].name == name) + return (int32_t)i; + } + + return NO_JOINT; +} + +const AnimationSequence* SkeletalMesh::GetAnimation(const stl::string &name) const +{ + STACK_TRACE; + AnimationList::const_iterator itor = m_animations.find(name); + if (itor != m_animations.end()) + return &itor->second; + else + return NULL; +} + +void SkeletalMesh::FindAndSetRootJointIndex() +{ + STACK_TRACE; + ASSERT(m_numJoints > 0); + + // if this mesh has only one joint, then that one has to be the root... + if (m_numJoints == 1) + { + m_rootJointIndex = 0; + return; + } + + uint32_t numJointsTried = 0; + int32_t rootIndex = NO_JOINT; + while (numJointsTried < m_numJoints && rootIndex == NO_JOINT) + { + int32_t parentlessJoint = NO_JOINT; + + // try the next joint without any parents + for (uint32_t i = numJointsTried; i < m_numJoints; ++i) + { + if (m_joints[i].parent == NULL) + { + parentlessJoint = (int32_t)i; + break; + } + } + if (parentlessJoint == NO_JOINT) + { + // no more joints without a parent to try + // this mesh doesn't have a valid root joint + // TODO: should this be considered an error? + break; + } + + // ensure it has child joints + BOOL hasChildJoints = FALSE; + for (uint32_t i = 0; i < m_numJoints; ++i) + { + int32_t parentIndex = m_joints[i].parentIndex; + if (parentIndex == parentlessJoint) + { + hasChildJoints = TRUE; + break; + } + } + + if (hasChildJoints) + rootIndex = parentlessJoint; + else + ++numJointsTried; + } + + m_rootJointIndex = rootIndex; +} diff --git a/src/framework/assets/animation/skeletalmesh.h b/src/framework/assets/animation/skeletalmesh.h new file mode 100644 index 0000000..e822f3d --- /dev/null +++ b/src/framework/assets/animation/skeletalmesh.h @@ -0,0 +1,62 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESH_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESH_H_INCLUDED__ + +#include "../../common.h" +#include "../../support/animationsequence.h" +#include "../../content/content.h" +#include + +class SkeletalMeshFile; +class SkeletalMeshSubset; +class VertexBuffer; +struct Joint; +struct JointVertexMapping; +struct Vector3; + +class SkeletalMesh : public Content +{ + friend class SkeletalMeshFile; + +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "SkeletalMesh"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + virtual ~SkeletalMesh(); + + uint32_t GetNumVertices() const { return m_numVertices; } + Vector3* GetVertices() const { return m_vertices; } + JointVertexMapping* GetJointMappings() const { return m_jointMappings; } + uint32_t GetNumSubsets() const { return m_numSubsets; } + SkeletalMeshSubset* GetSubsets() const { return m_subsets; } + int32_t GetIndexOfSubset(const stl::string &name) const; + uint32_t GetNumJoints() const { return m_numJoints; } + Joint* GetJoints() const { return m_joints; } + Joint* GetJoint(const stl::string &name) const; + int32_t GetIndexOfJoint(const stl::string &name) const; + int32_t GetRootJointIndex() const { return m_rootJointIndex; } + uint32_t GetNumFrames() const { return m_numFrames; } + const AnimationSequence* GetAnimation(const stl::string &name) const; + VertexBuffer* GetVertexBuffer() const { return m_vertexBuffer; } + +private: + SkeletalMesh(); + void FindAndSetRootJointIndex(); + + uint32_t m_numVertices; + Vector3 *m_vertices; + JointVertexMapping *m_jointMappings; + uint32_t m_numSubsets; + SkeletalMeshSubset *m_subsets; + uint32_t m_numJoints; + Joint *m_joints; + int32_t m_rootJointIndex; + uint32_t m_numFrames; + AnimationList m_animations; + VertexBuffer *m_vertexBuffer; +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshanimationinstance.cpp b/src/framework/assets/animation/skeletalmeshanimationinstance.cpp new file mode 100644 index 0000000..9743c47 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshanimationinstance.cpp @@ -0,0 +1,119 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "skeletalmeshanimationinstance.h" +#include "skeletalmeshinstance.h" +#include "skeletalmesh.h" +#include "../../support/animationsequence.h" +#include + +SkeletalMeshAnimationInstance::SkeletalMeshAnimationInstance(SkeletalMesh *mesh) + : SkeletalMeshInstance(mesh) +{ + STACK_TRACE; + m_currentSequenceStart = 0; + m_currentSequenceEnd = 0; + m_currentSequenceLoop = FALSE; + m_thisFrame = 0; + m_nextFrame = 0; + m_interpolation = 0.0f; + m_isRunningTempSequence = FALSE; + m_oldSequenceLoop = FALSE; +} + +SkeletalMeshAnimationInstance::~SkeletalMeshAnimationInstance() +{ + STACK_TRACE; +} + +void SkeletalMeshAnimationInstance::OnUpdate(float delta) +{ + STACK_TRACE; + SkeletalMeshInstance::OnUpdate(delta); + if (m_currentSequenceStart != m_currentSequenceEnd) + { + m_interpolation += delta * 30; + if (m_interpolation >= 1.0f) + { + m_interpolation = 0.0f; + + ++m_thisFrame; + if (m_thisFrame > m_currentSequenceEnd) + { + m_thisFrame = m_currentSequenceStart; + + if (m_isRunningTempSequence) + { + RecoverFromTempSequence(); + return; + } + if (!m_currentSequenceLoop) + { + m_currentSequenceStart = m_currentSequenceEnd; + m_thisFrame = m_currentSequenceEnd; + m_nextFrame = m_thisFrame; + return; + } + } + + ++m_nextFrame; + if (m_nextFrame > m_currentSequenceEnd) + { + if (!m_currentSequenceLoop) + m_nextFrame = m_currentSequenceEnd; + else + m_nextFrame = m_currentSequenceStart; + } + } + } +} + +void SkeletalMeshAnimationInstance::SetSequence(uint32_t startFrame, uint32_t endFrame, BOOL loop) +{ + STACK_TRACE; + m_currentSequenceName.clear(); + m_currentSequenceStart = startFrame; + m_currentSequenceEnd = endFrame; + m_currentSequenceLoop = loop; + + m_thisFrame = m_currentSequenceStart; + m_nextFrame = m_thisFrame + 1; + if (m_nextFrame > m_currentSequenceEnd) + m_nextFrame = m_currentSequenceEnd; + + m_interpolation = 0.0f; +} + +void SkeletalMeshAnimationInstance::SetSequence(const stl::string &name, BOOL loop) +{ + STACK_TRACE; + if (m_currentSequenceName == name) + return; + + const AnimationSequence *sequence = GetMesh()->GetAnimation(name); + ASSERT(sequence != NULL); + SetSequence(sequence->start, sequence->stop, loop); + m_currentSequenceName = name;} + +void SkeletalMeshAnimationInstance::RunSequenceOnce(const stl::string &name) +{ + STACK_TRACE; + if (m_isRunningTempSequence) + return; + + m_oldSequenceName = m_currentSequenceName; + m_oldSequenceLoop = m_currentSequenceLoop; + + m_isRunningTempSequence = TRUE; + + SetSequence(name, FALSE); +} + +void SkeletalMeshAnimationInstance::RecoverFromTempSequence() +{ + STACK_TRACE; + m_isRunningTempSequence = FALSE; + SetSequence(m_oldSequenceName, m_oldSequenceLoop); + m_oldSequenceName.clear(); + m_oldSequenceLoop = false; +} diff --git a/src/framework/assets/animation/skeletalmeshanimationinstance.h b/src/framework/assets/animation/skeletalmeshanimationinstance.h new file mode 100644 index 0000000..01fb4ef --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshanimationinstance.h @@ -0,0 +1,40 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHANIMATIONINSTANCE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHANIMATIONINSTANCE_H_INCLUDED__ + +#include "../../common.h" +#include "skeletalmeshinstance.h" +#include + +class SkeletalMesh; + +class SkeletalMeshAnimationInstance : public SkeletalMeshInstance +{ +public: + SkeletalMeshAnimationInstance(SkeletalMesh *mesh); + virtual ~SkeletalMeshAnimationInstance(); + + void OnUpdate(float delta); + void SetSequence(uint32_t startFrame, uint32_t endFrame, BOOL loop); + void SetSequence(const stl::string &name, BOOL loop); + void RunSequenceOnce(const stl::string &name); + + uint32_t GetCurrentFrame() const { return m_thisFrame; } + uint32_t GetNextFrame() const { return m_nextFrame; } + float GetInterpolation() const { return m_interpolation; } + +private: + void RecoverFromTempSequence(); + + stl::string m_currentSequenceName; + uint32_t m_currentSequenceStart; + uint32_t m_currentSequenceEnd; + BOOL m_currentSequenceLoop; + uint32_t m_thisFrame; + uint32_t m_nextFrame; + float m_interpolation; + BOOL m_isRunningTempSequence; + stl::string m_oldSequenceName; + BOOL m_oldSequenceLoop; +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshfile.cpp b/src/framework/assets/animation/skeletalmeshfile.cpp new file mode 100644 index 0000000..130e368 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshfile.cpp @@ -0,0 +1,269 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "joint.h" +#include "jointkeyframe.h" +#include "jointvertexmapping.h" +#include "skeletalmesh.h" +#include "skeletalmeshfile.h" +#include "skeletalmeshsubset.h" +#include "skeletalmeshtriangle.h" +#include "../../file/file.h" +#include "../../graphics/indexbuffer.h" +#include "../../graphics/vertexbuffer.h" +#include "../../math/quaternion.h" +#include "../../math/vector3.h" +#include "../../support/animationsequence.h" +#include + +SkeletalMeshFile::SkeletalMeshFile(File *file) + : MeshFile(file) +{ + STACK_TRACE; +} + +SkeletalMeshFile::~SkeletalMeshFile() +{ + STACK_TRACE; +} + +SkeletalMesh* SkeletalMeshFile::CreateMesh() +{ + STACK_TRACE; + ChunkDescriptor *verticesDesc = GetChunkDesc("VTX"); + ChunkDescriptor *normalsDesc = GetChunkDesc("NRL"); + ChunkDescriptor *texCoordsDesc = GetChunkDesc("TXT"); + ChunkDescriptor *trianglesDesc = GetChunkDesc("TRI"); + ChunkDescriptor *groupsDesc = GetChunkDesc("GRP"); + ChunkDescriptor *jointsDesc = GetChunkDesc("JNT"); + ChunkDescriptor *jointsToVerticesDesc = GetChunkDesc("JTV"); + ChunkDescriptor *jointFramesDesc = GetChunkDesc("JKF"); + ChunkDescriptor *animationsDesc = GetChunkDesc("ANI"); + ASSERT(verticesDesc != NULL); + ASSERT(trianglesDesc != NULL); + ASSERT(groupsDesc != NULL); + ASSERT(jointsDesc != NULL); + ASSERT(jointsToVerticesDesc != NULL); + + BOOL hasNormals = (normalsDesc != NULL ? TRUE : FALSE); + BOOL hasTexCoords = (texCoordsDesc != NULL ? TRUE : FALSE); + + File *file = GetFile(); + SkeletalMesh *mesh = new SkeletalMesh(); + + // read number of vertices first + // NOTE: we assume # of vertices == # of normals == # of tex coords + file->Seek(verticesDesc->start, FILESEEK_BEGINNING); + mesh->m_numVertices = file->ReadUnsignedInt(); + + mesh->m_vertexBuffer = new VertexBuffer(BUFFEROBJECT_USAGE_STATIC); + mesh->m_vertexBuffer->AddAttribute(ATTRIB_SIZE_1F); + mesh->m_vertexBuffer->AddAttribute(VERTEX_POS_3D); + if (hasNormals) + mesh->m_vertexBuffer->AddAttribute(VERTEX_NORMAL); + if (hasTexCoords) + mesh->m_vertexBuffer->AddAttribute(VERTEX_TEXCOORD); + mesh->m_vertexBuffer->Create(mesh->m_numVertices); + + // read vertices + mesh->m_vertices = new Vector3[mesh->m_numVertices]; + for (uint32_t i = 0; i < mesh->m_numVertices; ++i) + { + mesh->m_vertices[i].x = file->ReadFloat(); + mesh->m_vertices[i].y = file->ReadFloat(); + mesh->m_vertices[i].z = file->ReadFloat(); + mesh->m_vertexBuffer->SetPosition3(i, mesh->m_vertices[i]); + } + + // normals + if (hasNormals) + { + file->Seek(normalsDesc->start, FILESEEK_BEGINNING); + uint32_t numNormals = file->ReadUnsignedInt(); + ASSERT(numNormals == mesh->m_numVertices); + for (uint32_t i = 0; i < numNormals; ++i) + { + Vector3 normal; + normal.x = file->ReadFloat(); + normal.y = file->ReadFloat(); + normal.z = file->ReadFloat(); + mesh->m_vertexBuffer->SetNormal(i, normal); + } + } + + // texture coords + if (hasTexCoords) + { + file->Seek(texCoordsDesc->start, FILESEEK_BEGINNING); + uint32_t numTexCoords = file->ReadUnsignedInt(); + ASSERT(numTexCoords == mesh->m_numVertices); + for (uint32_t i = 0; i < numTexCoords; ++i) + { + Vector2 texCoord; + texCoord.x = file->ReadFloat(); + texCoord.y = file->ReadFloat(); + mesh->m_vertexBuffer->SetTexCoord(i, texCoord); + } + } + + // groups / subsets + file->Seek(groupsDesc->start, FILESEEK_BEGINNING); + mesh->m_numSubsets = file->ReadUnsignedInt(); + mesh->m_subsets = new SkeletalMeshSubset[mesh->m_numSubsets]; + for (uint32_t i = 0; i < mesh->m_numSubsets; ++i) + { + stl::string name; + stl::string texture; + BOOL alpha; + uint32_t numTriangles; + + file->ReadString(name); + file->ReadString(texture); + alpha = file->ReadChar() == 0 ? FALSE : TRUE; + numTriangles = file->ReadUnsignedInt(); + + mesh->m_subsets[i].Create(name, numTriangles, alpha); + mesh->m_subsets[i].GetIndices()->MoveToStart(); + } + + // triangles + file->Seek(trianglesDesc->start, FILESEEK_BEGINNING); + uint32_t numTriangles = file->ReadUnsignedInt(); + for (uint32_t i = 0; i < numTriangles; ++i) + { + uint32_t v1 = file->ReadUnsignedInt(); + uint32_t v2 = file->ReadUnsignedInt(); + uint32_t v3 = file->ReadUnsignedInt(); + uint32_t subsetIndex = file->ReadUnsignedInt(); + + SkeletalMeshSubset *subset = &mesh->m_subsets[subsetIndex]; + subset->GetIndices()->SetCurrent((uint16_t)v1); + subset->GetIndices()->MoveNext(); + subset->GetIndices()->SetCurrent((uint16_t)v2); + subset->GetIndices()->MoveNext(); + subset->GetIndices()->SetCurrent((uint16_t)v3); + subset->GetIndices()->MoveNext(); + } + + // joints + file->Seek(jointsDesc->start, FILESEEK_BEGINNING); + mesh->m_numJoints = file->ReadUnsignedInt(); + mesh->m_joints = new Joint[mesh->m_numJoints]; + for (uint32_t i = 0; i < mesh->m_numJoints; ++i) + { + file->ReadString(mesh->m_joints[i].name); + int32_t parentIndex = file->ReadInt(); + mesh->m_joints[i].parentIndex = parentIndex; + if (parentIndex >= 0) + mesh->m_joints[i].parent = &mesh->m_joints[parentIndex]; + + Vector3 initialPosition; + initialPosition.x = file->ReadFloat(); + initialPosition.y = file->ReadFloat(); + initialPosition.z = file->ReadFloat(); + + float rotationX = file->ReadFloat(); + float rotationY = file->ReadFloat(); + float rotationZ = file->ReadFloat(); + Quaternion initialRotation = Quaternion::CreateFromEulerAngles(rotationX, rotationY, rotationZ); + + mesh->m_joints[i].relative = + Matrix4x4::CreateTranslation(initialPosition.x, initialPosition.y, initialPosition.z) * + initialRotation.ToMatrix(); + } + + // build absolute transformation matrices for all the joints we just loaded + for (uint32_t i = 0; i < mesh->m_numJoints; ++i) + { + Joint *joint = &mesh->m_joints[i]; + if (joint->parent != NULL) + { + joint->absolute = joint->parent->absolute; + joint->absolute = joint->absolute * joint->relative; + } + else + joint->absolute = joint->relative; + } + + // set up inverse absolute transforms for each joint in preparation + // for transforming all the vertices + Matrix4x4 *inverseJointTransforms = new Matrix4x4[mesh->m_numJoints]; + for (uint32_t i = 0; i < mesh->m_numJoints; ++i) + inverseJointTransforms[i] = Matrix4x4::Inverse(mesh->m_joints[i].absolute); + + // joint-to-vertex mappings + file->Seek(jointsToVerticesDesc->start, FILESEEK_BEGINNING); + uint32_t numMappings = file->ReadUnsignedInt(); + ASSERT(numMappings == mesh->m_numVertices); + mesh->m_jointMappings = new JointVertexMapping[numMappings]; + for (uint32_t i = 0; i < numMappings; ++i) + { + uint32_t jointIndex = file->ReadUnsignedInt(); + mesh->m_jointMappings[i].jointIndex = jointIndex; + mesh->m_jointMappings[i].weight = file->ReadFloat(); + + // set joint index for this vertex in the VBO + mesh->m_vertexBuffer->Set1f(0, i, (float)jointIndex); + + // transform vertex by it's joint's inverse absolute transform + Vector3 vertex = mesh->m_vertexBuffer->GetPosition3(i); + vertex = Matrix4x4::Transform(inverseJointTransforms[jointIndex], vertex); + mesh->m_vertexBuffer->SetPosition3(i, vertex); + + // transform normal by it's joint's inverse absolute transform + if (hasNormals) + { + Vector3 normal = mesh->m_vertexBuffer->GetNormal(i); + normal = Matrix4x4::TransformUsingRotationOnly(inverseJointTransforms[jointIndex], normal); + mesh->m_vertexBuffer->SetNormal(i, normal); + } + } + + // joint keyframes + if (jointFramesDesc != NULL) + { + file->Seek(jointFramesDesc->start, FILESEEK_BEGINNING); + mesh->m_numFrames = file->ReadUnsignedInt(); + + // allocate memory for the frames for each joint + for (uint32_t i = 0; i < mesh->m_numJoints; ++i) + mesh->m_joints[i].frames = new JointKeyFrame[mesh->m_numFrames]; + + for (uint32_t i = 0; i < mesh->m_numFrames; ++i) + { + for (uint32_t j = 0; j < mesh->m_numJoints; ++j) + { + mesh->m_joints[j].frames[i].position.x = file->ReadFloat(); + mesh->m_joints[j].frames[i].position.y = file->ReadFloat(); + mesh->m_joints[j].frames[i].position.z = file->ReadFloat(); + + float rotationX = file->ReadFloat(); + float rotationY = file->ReadFloat(); + float rotationZ = file->ReadFloat(); + mesh->m_joints[j].frames[i].rotation = Quaternion::CreateFromEulerAngles(rotationX, rotationY, rotationZ); + } + } + } + + // animations + if (animationsDesc != NULL) + { + file->Seek(animationsDesc->start, FILESEEK_BEGINNING); + int32_t numAnimations = file->ReadInt(); + for (int32_t i = 0; i < numAnimations; ++i) + { + AnimationSequence sequence; + stl::string name; + + file->ReadString(name); + sequence.start = file->ReadInt(); + sequence.stop = file->ReadInt(); + + mesh->m_animations[name] = sequence; + } + } + + mesh->FindAndSetRootJointIndex(); + + return mesh; +} diff --git a/src/framework/assets/animation/skeletalmeshfile.h b/src/framework/assets/animation/skeletalmeshfile.h new file mode 100644 index 0000000..9e490e2 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshfile.h @@ -0,0 +1,19 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHFILE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHFILE_H_INCLUDED__ + +#include "../../common.h" +#include "../meshfile.h" + +class File; +class SkeletalMesh; + +class SkeletalMeshFile : public MeshFile +{ +public: + SkeletalMeshFile(File *file); + virtual ~SkeletalMeshFile(); + + SkeletalMesh* CreateMesh(); +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshinstance.cpp b/src/framework/assets/animation/skeletalmeshinstance.cpp new file mode 100644 index 0000000..1d1db62 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshinstance.cpp @@ -0,0 +1,202 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "skeletalmeshinstance.h" +#include "skeletalmesh.h" +#include "joint.h" +#include "jointkeyframe.h" +#include "../../graphics/blendstate.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/texture.h" +#include "../../math/matrix4x4.h" +#include "../../math/quaternion.h" +#include "../../math/vector3.h" +#include + +SkeletalMeshInstance::SkeletalMeshInstance(SkeletalMesh *mesh) +{ + STACK_TRACE; + m_mesh = mesh; + + m_numSubsets = m_mesh->GetNumSubsets(); + + m_enabledSubsets = new BOOL[m_numSubsets]; + m_textures = new Texture*[m_numSubsets]; + + for (uint32_t i = 0; i < m_numSubsets; ++i) + { + m_enabledSubsets[i] = TRUE; + m_textures[i] = NULL; + } + + m_renderState = new RENDERSTATE_DEFAULT; + m_blendState = new BLENDSTATE_DEFAULT; + m_alphaBlendState = new BLENDSTATE_ALPHABLEND; + m_renderAllSubsetsAlphaBlended = FALSE; + + m_numJoints = mesh->GetNumJoints(); + m_jointTransformations = new Matrix4x4[m_numJoints]; + m_jointPositions = new Vector3[m_numJoints]; + m_jointRotations = new Quaternion[m_numJoints]; + m_rootJointHasFixedTransform = FALSE; +} + +SkeletalMeshInstance::~SkeletalMeshInstance() +{ + STACK_TRACE; + SAFE_DELETE(m_renderState); + SAFE_DELETE(m_blendState); + SAFE_DELETE(m_alphaBlendState); + SAFE_DELETE_ARRAY(m_enabledSubsets); + SAFE_DELETE_ARRAY(m_textures); + SAFE_DELETE_ARRAY(m_jointTransformations); + SAFE_DELETE_ARRAY(m_jointPositions); + SAFE_DELETE_ARRAY(m_jointRotations); +} + +void SkeletalMeshInstance::OnUpdate(float delta) +{ + STACK_TRACE; +} + +const Matrix4x4* SkeletalMeshInstance::GetJointTransformation(const stl::string &jointName) const +{ + STACK_TRACE; + int32_t jointIndex = GetMesh()->GetIndexOfJoint(jointName); + if (jointIndex == NO_JOINT) + return NULL; + else + return &m_jointTransformations[jointIndex]; +} + +void SkeletalMeshInstance::SetFixedRootJointTransformation(const Matrix4x4 &transform) +{ + STACK_TRACE; + ASSERT(GetMesh()->GetRootJointIndex() != NO_JOINT); + m_rootJointHasFixedTransform = TRUE; + m_jointTransformations[GetMesh()->GetRootJointIndex()] = transform; +} + +void SkeletalMeshInstance::ClearFixedRootJointTransformation() +{ + STACK_TRACE; + ASSERT(GetMesh()->GetRootJointIndex() != NO_JOINT); + m_rootJointHasFixedTransform = FALSE; +} + +void SkeletalMeshInstance::CalculateJointTransformations(uint32_t frame) +{ + STACK_TRACE; + int32_t rootJointIndex = GetMesh()->GetRootJointIndex(); + + for (uint32_t i = 0; i < m_numJoints; ++i) + { + if (!(m_rootJointHasFixedTransform && i == rootJointIndex)) + { + Joint *joint = &GetMesh()->GetJoints()[i]; + + const Vector3 *translation = &joint->frames[frame].position; + const Quaternion *rotation = &joint->frames[frame].rotation; + + Matrix4x4 transform = + joint->relative * + Matrix4x4::CreateTranslation(translation->x, translation->y, translation->z) * + rotation->ToMatrix(); + + if (joint->parent != NULL) + { + // concatenate this joint's transformation onto the parent's + // transformation + m_jointTransformations[i] = m_jointTransformations[joint->parentIndex]; + m_jointTransformations[i] *= transform; + } + else + { + // no parent, just use this joint's relative final transformation + // as the final transformation + m_jointTransformations[i] = transform; + } + } + + BreakDownJointTransformationMatrix(i); + } +} + +void SkeletalMeshInstance::CalculateJointTransformations(uint32_t startFrame, uint32_t endFrame, float interpolation) +{ + STACK_TRACE; + int32_t rootJointIndex = GetMesh()->GetRootJointIndex(); + + for (uint32_t i = 0; i < m_numJoints; ++i) + { + if (!(m_rootJointHasFixedTransform && i == rootJointIndex)) + { + Joint *joint = &GetMesh()->GetJoints()[i]; + const JointKeyFrame *frame1 = &joint->frames[startFrame]; + const JointKeyFrame *frame2 = &joint->frames[endFrame]; + + // interpolate translation and rotation + Vector3 translation = Vector3::Lerp(frame1->position, frame2->position, interpolation); + Quaternion rotation = Quaternion::Slerp(frame1->rotation, frame2->rotation, interpolation); + + Matrix4x4 transform = + joint->relative * + Matrix4x4::CreateTranslation(translation.x, translation.y, translation.z) * + rotation.ToMatrix(); + + if (joint->parent != NULL) + { + // concatenate this joint's transformation onto the parent's + // transformation + m_jointTransformations[i] = m_jointTransformations[joint->parentIndex]; + m_jointTransformations[i] *= transform; + } + else + { + // no parent, just use this joint's relative final transformation + // as the final transformation + m_jointTransformations[i] = transform; + } + } + + BreakDownJointTransformationMatrix(i); + } +} + +void SkeletalMeshInstance::BreakDownJointTransformationMatrix(uint32_t jointMatrixIndex) +{ + STACK_TRACE; + const Matrix4x4 *jointMatrix = &m_jointTransformations[jointMatrixIndex]; + + m_jointPositions[jointMatrixIndex] = jointMatrix->GetTranslation(); + m_jointRotations[jointMatrixIndex] = Quaternion::CreateFromRotationMatrix(*jointMatrix); +} + +void SkeletalMeshInstance::EnableSubset(const stl::string &subset, BOOL enable) +{ + STACK_TRACE; + int32_t index = m_mesh->GetIndexOfSubset(subset); + ASSERT(index != -1); + if (index == -1) + return; + else + m_enabledSubsets[index] = enable; +} + +void SkeletalMeshInstance::SetTexture(uint32_t index, Texture *texture) +{ + STACK_TRACE; + ASSERT(index < m_numSubsets); + m_textures[index] = texture; +} + +void SkeletalMeshInstance::SetTexture(const stl::string &subset, Texture *texture) +{ + STACK_TRACE; + int32_t index = m_mesh->GetIndexOfSubset(subset); + ASSERT(index != -1); + if (index == -1) + return; + else + m_textures[index] = texture; +} diff --git a/src/framework/assets/animation/skeletalmeshinstance.h b/src/framework/assets/animation/skeletalmeshinstance.h new file mode 100644 index 0000000..8b2a723 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshinstance.h @@ -0,0 +1,70 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHINSTANCE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHINSTANCE_H_INCLUDED__ + +#include "../../common.h" +#include + +class BlendState; +class RenderState; +class SkeletalMesh; +class Texture; +struct Matrix4x4; +struct Vector3; +struct Quaternion; + +class SkeletalMeshInstance +{ +public: + SkeletalMeshInstance(SkeletalMesh *mesh); + virtual ~SkeletalMeshInstance(); + + virtual void OnUpdate(float delta); + void CalculateJointTransformations(uint32_t frame); + void CalculateJointTransformations(uint32_t startFrame, uint32_t endFrame, float interpolation); + + uint32_t GetNumSubsets() const { return m_numSubsets; } + BOOL IsSubsetEnabled(uint32_t index) const { return m_enabledSubsets[index]; } + void EnableSubset(const stl::string &subset, BOOL enable); + void EnableSubset(uint32_t index, BOOL enable) { m_enabledSubsets[index] = enable; } + + Texture** GetTextures() const { return m_textures; } + void SetTexture(uint32_t index, Texture *texture); + void SetTexture(const stl::string &subset, Texture *texture); + + uint32_t GetNumJoints() const { return m_numJoints; } + Matrix4x4* GetJointTransformations() const { return m_jointTransformations; } + Vector3* GetJointPositions() const { return m_jointPositions; } + Quaternion* GetJointRotations() const { return m_jointRotations; } + const Matrix4x4* GetJointTransformation(const stl::string &jointName) const; + void SetFixedRootJointTransformation(const Matrix4x4 &transform); + void ClearFixedRootJointTransformation(); + + RenderState* GetRenderState() const { return m_renderState; } + BlendState* GetBlendState() const { return m_blendState; } + BlendState* GetAlphaBlendState() const { return m_alphaBlendState; } + + BOOL GetRenderAllSubsetsAlphaBlended() const { return m_renderAllSubsetsAlphaBlended; } + void SetRenderAllSubsetsAlphaBlended(BOOL enable) { m_renderAllSubsetsAlphaBlended = enable; } + + SkeletalMesh* GetMesh() const { return m_mesh; } + +private: + void BreakDownJointTransformationMatrix(uint32_t jointMatrixIndex); + + SkeletalMesh *m_mesh; + uint32_t m_numSubsets; + BOOL *m_enabledSubsets; + Texture **m_textures; + RenderState *m_renderState; + BlendState *m_blendState; + BlendState *m_alphaBlendState; + BOOL m_renderAllSubsetsAlphaBlended; + + uint32_t m_numJoints; + Matrix4x4 *m_jointTransformations; + Vector3 *m_jointPositions; + Quaternion *m_jointRotations; + BOOL m_rootJointHasFixedTransform; +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshrenderer.cpp b/src/framework/assets/animation/skeletalmeshrenderer.cpp new file mode 100644 index 0000000..5ff5c06 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshrenderer.cpp @@ -0,0 +1,117 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "skeletalmeshrenderer.h" +#include "skeletalmesh.h" +#include "skeletalmeshinstance.h" +#include "skeletalmeshanimationinstance.h" +#include "skeletalmeshsubset.h" +#include "../../graphics/blendstate.h" +#include "../../graphics/graphicsdevice.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/texture.h" +#include "../../graphics/vertexskinningshader.h" + +SkeletalMeshRenderer::SkeletalMeshRenderer() +{ + STACK_TRACE; +} + +SkeletalMeshRenderer::~SkeletalMeshRenderer() +{ + STACK_TRACE; +} + +void SkeletalMeshRenderer::Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, VertexSkinningShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + Render(graphicsDevice, instance, 0, shader); +} + +void SkeletalMeshRenderer::Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, uint32_t frame, VertexSkinningShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + instance->CalculateJointTransformations(frame); + shader->SetJointPositions(instance->GetJointPositions(), instance->GetNumJoints()); + shader->SetJointRotations(instance->GetJointRotations(), instance->GetNumJoints()); + RenderAllSubsets(graphicsDevice, instance, shader); +} + +void SkeletalMeshRenderer::Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexSkinningShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + instance->CalculateJointTransformations(startFrame, endFrame, interpolation); + shader->SetJointPositions(instance->GetJointPositions(), instance->GetNumJoints()); + shader->SetJointRotations(instance->GetJointRotations(), instance->GetNumJoints()); + RenderAllSubsets(graphicsDevice, instance, shader); +} + +void SkeletalMeshRenderer::Render(GraphicsDevice *graphicsDevice, SkeletalMeshAnimationInstance *instance, VertexSkinningShader *shader) +{ + STACK_TRACE; + ASSERT(shader->IsBound() == TRUE); + Render(graphicsDevice, instance, instance->GetCurrentFrame(), instance->GetNextFrame(), instance->GetInterpolation(), shader); +} + +void SkeletalMeshRenderer::RenderAllSubsets(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, VertexSkinningShader *shader) +{ + STACK_TRACE; + instance->GetRenderState()->Apply(); + graphicsDevice->BindVertexBuffer(instance->GetMesh()->GetVertexBuffer()); + + BOOL hasAlphaSubsets = FALSE; + + if (instance->GetRenderAllSubsetsAlphaBlended()) + { + // this instance has been overridden to have all it's subsets rendered + // with alpha blending enabled. don't bother with the first loop to find + // non-alpha-enabled subsets... + hasAlphaSubsets = TRUE; + } + else + { + // render only non-alpha subsets first + instance->GetBlendState()->Apply(); + for (uint32_t i = 0; i < instance->GetMesh()->GetNumSubsets(); ++i) + { + if (!instance->IsSubsetEnabled(i)) + continue; + + const SkeletalMeshSubset *subset = &instance->GetMesh()->GetSubsets()[i]; + if (subset->IsAlphaBlended()) + // note we have an alpha subset, but don't render it quite yet + hasAlphaSubsets = TRUE; + else + RenderSubset(graphicsDevice, subset, instance->GetTextures()[i]); + } + } + + // now render only alpha subsets, if we found any + if (hasAlphaSubsets) + { + instance->GetAlphaBlendState()->Apply(); + for (uint32_t i = 0; i < instance->GetMesh()->GetNumSubsets(); ++i) + { + if (!instance->IsSubsetEnabled(i)) + continue; + + const SkeletalMeshSubset *subset = &instance->GetMesh()->GetSubsets()[i]; + if (subset->IsAlphaBlended() || instance->GetRenderAllSubsetsAlphaBlended()) + RenderSubset(graphicsDevice, subset, instance->GetTextures()[i]); + } + } +} + +void SkeletalMeshRenderer::RenderSubset(GraphicsDevice *graphicsDevice, const SkeletalMeshSubset *subset, const Texture *texture) +{ + STACK_TRACE; + if (texture != NULL) + graphicsDevice->BindTexture(texture); + + graphicsDevice->BindIndexBuffer(subset->GetIndices()); + graphicsDevice->RenderTriangles(); + graphicsDevice->UnbindIndexBuffer(); +} diff --git a/src/framework/assets/animation/skeletalmeshrenderer.h b/src/framework/assets/animation/skeletalmeshrenderer.h new file mode 100644 index 0000000..a1aa3d9 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshrenderer.h @@ -0,0 +1,31 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHRENDERER_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHRENDERER_H_INCLUDED__ + +#include "../../common.h" + +class GraphicsDevice; +class SkeletalMesh; +class SkeletalMeshInstance; +class SkeletalMeshAnimationInstance; +class SkeletalMeshSubset; +class Texture; +class VertexSkinningShader; +struct Matrix4x4; + +class SkeletalMeshRenderer +{ +public: + SkeletalMeshRenderer(); + virtual ~SkeletalMeshRenderer(); + + void Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, VertexSkinningShader *shader); + void Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, uint32_t frame, VertexSkinningShader *shader); + void Render(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, uint32_t startFrame, uint32_t endFrame, float interpolation, VertexSkinningShader *shader); + void Render(GraphicsDevice *graphicsDevice, SkeletalMeshAnimationInstance *instance, VertexSkinningShader *shader); + +private: + void RenderAllSubsets(GraphicsDevice *graphicsDevice, SkeletalMeshInstance *instance, VertexSkinningShader *shader); + void RenderSubset(GraphicsDevice *graphicsDevice, const SkeletalMeshSubset *subset, const Texture *texture); +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshsubset.cpp b/src/framework/assets/animation/skeletalmeshsubset.cpp new file mode 100644 index 0000000..01fa1c5 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshsubset.cpp @@ -0,0 +1,29 @@ +#include "../../debug.h" + +#include "../../common.h" +#include "skeletalmeshsubset.h" +#include "../../graphics/indexbuffer.h" +#include + +SkeletalMeshSubset::SkeletalMeshSubset() +{ + STACK_TRACE; + m_indices = NULL; + m_alpha = FALSE; +} + +SkeletalMeshSubset::~SkeletalMeshSubset() +{ + STACK_TRACE; + SAFE_DELETE(m_indices); +} + +void SkeletalMeshSubset::Create(const stl::string &name, uint32_t numTriangles, BOOL alpha) +{ + STACK_TRACE; + ASSERT(m_indices == NULL); + ASSERT(numTriangles > 0); + m_name = name; + m_indices = new IndexBuffer(numTriangles * 3, TRUE); + m_alpha = alpha; +} diff --git a/src/framework/assets/animation/skeletalmeshsubset.h b/src/framework/assets/animation/skeletalmeshsubset.h new file mode 100644 index 0000000..c84a8d4 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshsubset.h @@ -0,0 +1,27 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHSUBSET_INCLUDED_H__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHSUBSET_INCLUDED_H__ + +#include "../../common.h" +#include + +class IndexBuffer; + +class SkeletalMeshSubset +{ +public: + SkeletalMeshSubset(); + virtual ~SkeletalMeshSubset(); + + void Create(const stl::string &name, uint32_t numTriangles, BOOL alpha); + + const stl::string& GetName() const { return m_name; } + IndexBuffer* GetIndices() const { return m_indices; } + BOOL IsAlphaBlended() const { return m_alpha; } + +private: + stl::string m_name; + IndexBuffer *m_indices; + BOOL m_alpha; +}; + +#endif diff --git a/src/framework/assets/animation/skeletalmeshtriangle.h b/src/framework/assets/animation/skeletalmeshtriangle.h new file mode 100644 index 0000000..b5491d7 --- /dev/null +++ b/src/framework/assets/animation/skeletalmeshtriangle.h @@ -0,0 +1,14 @@ +#ifndef __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHTRIANGLE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_ANIMATION_SKELETALMESHTRIANGLE_H_INCLUDED__ + +#include "../../common.h" +#include "../../math/vector2.h" +#include "../../math/vector3.h" + +struct SkeletalMeshTriangle +{ + int32_t vertices[3]; + int32_t subMeshIndex; +}; + +#endif diff --git a/src/framework/assets/chunkdescriptor.h b/src/framework/assets/chunkdescriptor.h new file mode 100644 index 0000000..9a1d503 --- /dev/null +++ b/src/framework/assets/chunkdescriptor.h @@ -0,0 +1,16 @@ +#ifndef __FRAMEWORK_ASSETS_CHUNKDESCRIPTOR_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_CHUNKDESCRIPTOR_H_INCLUDED__ + +#include "../common.h" +#include +#include + +struct ChunkDescriptor +{ + uint32_t start; + uint32_t length; +}; + +typedef stl::map ChunkMap; + +#endif diff --git a/src/framework/assets/meshfile.cpp b/src/framework/assets/meshfile.cpp new file mode 100644 index 0000000..94c1d56 --- /dev/null +++ b/src/framework/assets/meshfile.cpp @@ -0,0 +1,68 @@ +#include "../debug.h" + +#include "meshfile.h" +#include "chunkdescriptor.h" +#include "../file/file.h" + +MeshFile::MeshFile(File *file) +{ + STACK_TRACE; + ASSERT(file != NULL); + ASSERT(file->IsOpen()); + m_file = file; + + char ident[4]; + m_file->Read((int8_t*)ident, 4); + if (ident[0] != 'M' || ident[1] != 'E' || ident[2] != 'S' || ident[3] != 'H') + ASSERT(!"Invalid MESH identifier."); + + char version = m_file->ReadChar(); + if (version > 1) + ASSERT(!"Unsupported MESH file version."); + + CollectChunks(); +} + +MeshFile::~MeshFile() +{ + STACK_TRACE; +} + +void MeshFile::CollectChunks() +{ + STACK_TRACE; + m_chunks.clear(); + + // start off just after the header (start of the first chunk) + m_file->Seek(5, FILESEEK_BEGINNING); + + uint32_t size; + char ident[4]; + ident[3] = '\0'; + + while (m_file->Read((int8_t*)ident, 3)) + { + // chunk header + size = m_file->ReadInt(); + + // save chunk info + ChunkDescriptor descriptor; + descriptor.start = m_file->Tell(); + descriptor.length = size; + stl::string name(ident); + m_chunks[name] = descriptor; + + // move to the next chunk + m_file->Seek(size, FILESEEK_CURRENT); + } +} + +ChunkDescriptor* MeshFile::GetChunkDesc(const stl::string &name) +{ + STACK_TRACE; + ChunkMap::iterator itor = m_chunks.find(name); + if (itor == m_chunks.end()) + return NULL; + else + return &itor->second; +} diff --git a/src/framework/assets/meshfile.h b/src/framework/assets/meshfile.h new file mode 100644 index 0000000..7129907 --- /dev/null +++ b/src/framework/assets/meshfile.h @@ -0,0 +1,51 @@ +#ifndef __FRAMEWORK_ASSETS_MESHFILE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_MESHFILE_H_INCLUDED__ + +#include "../common.h" + +#include "chunkdescriptor.h" +#include + +class File; + +/** + * Base class for mesh files that are loaded using a custom "chunked" + * file format. + */ +class MeshFile +{ +public: + virtual ~MeshFile(); + +protected: + /** + * Initializes basic mesh file information from the provided mesh file. + * @param file the mesh file this object is for + */ + MeshFile(File *file); + + /** + * Passes through the entire file collecting information for each chunk + * present in the file. + */ + void CollectChunks(); + + /** + * Returns information about a specific chunk. + * @param name the name / identifier of the chunk to retrieve + * @return info about the chunk or NULL if the chunk wasn't found + */ + ChunkDescriptor* GetChunkDesc(const stl::string &name); + + /** + * @return the underlying file object for this mesh file + */ + File* GetFile() { return m_file; } + +private: + File *m_file; + ChunkMap m_chunks; + +}; + +#endif diff --git a/src/framework/assets/static/staticmesh.cpp b/src/framework/assets/static/staticmesh.cpp new file mode 100644 index 0000000..2c3b02f --- /dev/null +++ b/src/framework/assets/static/staticmesh.cpp @@ -0,0 +1,101 @@ +#include "../../debug.h" + +#include "staticmesh.h" + +#include "staticmeshfile.h" +#include "staticmeshsubset.h" +#include "staticmeshtriangle.h" +#include "../../content/contentmanager.h" +#include "../../graphics/texture.h" +#include "../../graphics/vertexbuffer.h" +#include "../../math/vector3.h" +#include "../../math/vector2.h" + +StaticMesh::StaticMesh(uint32_t numSubsets, StaticMeshSubset **subsets) + : Content() +{ + STACK_TRACE; + ASSERT(numSubsets > 0); + ASSERT(subsets != NULL); + + // important to note: this object is now assuming responsibility for the + // memory allocated to the StaticMeshSubset objects passed in. so this + // object should delete them when we're done, and not the caller + m_numSubsets = numSubsets; + m_subsets = subsets; +} + +StaticMesh::StaticMesh(const StaticMeshFile *file, ContentManager *contentManager) + : Content() +{ + STACK_TRACE; + m_numSubsets = 0; + CreateSubsets(file, contentManager); +} + +StaticMesh::~StaticMesh() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_numSubsets; ++i) + SAFE_DELETE(m_subsets[i]); + SAFE_DELETE_ARRAY(m_subsets); +} + +void StaticMesh::CreateSubsets(const StaticMeshFile *file, ContentManager *contentManager) +{ + STACK_TRACE; + m_numSubsets = file->GetNumSubMeshes(); + m_subsets = new StaticMeshSubset*[m_numSubsets]; + ASSERT(m_subsets != NULL); + + StaticMeshTriangle *triangles = file->GetTriangles(); + StaticMeshFileMaterial *materials = file->GetMaterials(); + StaticMeshFileSubMesh *subMeshes = file->GetSubMeshes(); + Vector3 *vertices = file->GetVertices(); + Vector3 *normals = file->GetNormals(); + Vector2 *texCoords = file->GetTexCoords(); + + for (uint32_t i = 0; i < m_numSubsets; ++i) + { + StaticMeshFileSubMesh *subMesh = &subMeshes[i]; + StaticMeshFileMaterial *material = &materials[subMesh->material]; + + Texture *texture = NULL; + if (material->textureFile.length() > 0) + texture = contentManager->Get(material->textureFile.c_str()); + StaticMeshSubset *subset = new StaticMeshSubset(subMesh->numTriangles, texture); + ASSERT(subset != NULL); + + // add the triangles to the subset + uint32_t n = 0; + for (uint32_t j = 0; j < file->GetNumTriangles(); ++j) + { + if (triangles[j].subMeshIndex == i) + { + uint32_t pos = n * 3; + + subset->GetVertices()->SetPosition3(pos, vertices[triangles[j].vertices[0]]); + subset->GetVertices()->SetPosition3(pos + 1, vertices[triangles[j].vertices[1]]); + subset->GetVertices()->SetPosition3(pos + 2, vertices[triangles[j].vertices[2]]); + + if (file->GetNumNormals() > 0) + { + subset->GetVertices()->SetNormal(pos, normals[triangles[j].vertices[0]]); + subset->GetVertices()->SetNormal(pos + 1, normals[triangles[j].vertices[1]]); + subset->GetVertices()->SetNormal(pos + 2, normals[triangles[j].vertices[2]]); + } + + if (file->GetNumTexCoords() > 0) + { + subset->GetVertices()->SetTexCoord(pos, texCoords[triangles[j].vertices[0]]); + subset->GetVertices()->SetTexCoord(pos + 1, texCoords[triangles[j].vertices[1]]); + subset->GetVertices()->SetTexCoord(pos + 2, texCoords[triangles[j].vertices[2]]); + } + + ++n; + } + } + + m_subsets[i] = subset; + } +} diff --git a/src/framework/assets/static/staticmesh.h b/src/framework/assets/static/staticmesh.h new file mode 100644 index 0000000..fcedf64 --- /dev/null +++ b/src/framework/assets/static/staticmesh.h @@ -0,0 +1,60 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESH_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESH_H_INCLUDED__ + +#include "../../common.h" +#include "../../content/content.h" + +class ContentManager; +class StaticMeshFile; +class StaticMeshSubset; + +/** + * Static mesh object containing geometry that does not animate. + */ +class StaticMesh : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "StaticMesh"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + /** + * Creates a static mesh object. + * @param numSubsets the number of subsets being provided + * @param subsets mesh subsets that this static mesh is to be made up of + */ + StaticMesh(uint32_t numSubsets, StaticMeshSubset **subsets); + + /** + * Creates a static mesh object. + * @param file the static mesh file to load the mesh data from + * @param contentManager the content manager that this mesh is being + * loaded from + */ + StaticMesh(const StaticMeshFile *file, ContentManager *contentManager); + + virtual ~StaticMesh(); + + /** + * @return the number of subsets that make up this mesh + */ + uint32_t GetNumSubsets() const { return m_numSubsets; } + + /** + * Gets the specified subset contained in this mesh. + * @param index the subset to get + * @return the mesh subset + */ + StaticMeshSubset* GetSubset(uint32_t index) const { return m_subsets[index]; } + +private: + void CreateSubsets(const StaticMeshFile *file, ContentManager *contentManager); + + uint32_t m_numSubsets; + StaticMeshSubset **m_subsets; +}; + +#endif diff --git a/src/framework/assets/static/staticmeshbuilder.cpp b/src/framework/assets/static/staticmeshbuilder.cpp new file mode 100644 index 0000000..8c8cfe4 --- /dev/null +++ b/src/framework/assets/static/staticmeshbuilder.cpp @@ -0,0 +1,343 @@ +#include "../../debug.h" + +#include "staticmeshbuilder.h" + +#include "staticmesh.h" +#include "staticmeshsubset.h" +#include "../../graphics/texture.h" +#include "../../graphics/vertexbuffer.h" +#include "../../math/matrix4x4.h" +#include "../../math/vector2.h" +#include "../../math/vector3.h" + +StaticMeshBuilder::StaticMeshBuilder() +{ + STACK_TRACE; + m_transform = IDENTITY_MATRIX; +} + +StaticMeshBuilder::~StaticMeshBuilder() +{ + STACK_TRACE; + // BuildMesh() will handle passing off the subset objects to a mesh object + // if it is called. if it's not called, this will free up the memory since + // it was never passed off anywhere else in that case + for (uint32_t i = 0; i < m_subsets.size(); ++i) + SAFE_DELETE(m_subsets[i]); + m_subsets.clear(); +} + +void StaticMeshBuilder::Reset() +{ + m_subsets.clear(); + m_transform = IDENTITY_MATRIX; +} + +uint32_t StaticMeshBuilder::AddSubset(uint32_t numTriangles, Texture *texture) +{ + STACK_TRACE; + ASSERT(numTriangles > 0); + StaticMeshSubset *subset = new StaticMeshSubset(numTriangles, texture); + ASSERT(subset != NULL); + + m_subsets.push_back(subset); + + return m_subsets.size() - 1; +} + +void StaticMeshBuilder::SetTriangle( + uint32_t subsetIndex, + uint32_t triangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ) +{ + STACK_TRACE; + ASSERT(m_subsets.size() > subsetIndex); + + StaticMeshSubset *subset = m_subsets[subsetIndex]; + ASSERT(subset != NULL); + + VertexBuffer *vertices = subset->GetVertices(); + uint32_t bufferIndex = triangle * 3; + + ASSERT((bufferIndex + 3) <= vertices->GetNumElements()); + + SetTriangleInternal( + vertices, bufferIndex, + v1, v2, v3, + n1, n2, n3, + t1, t2, t3 + ); +} + +void StaticMeshBuilder::SetTriangle( + uint32_t subsetIndex, + uint32_t triangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ) +{ + STACK_TRACE; + ASSERT(m_subsets.size() > subsetIndex); + + StaticMeshSubset *subset = m_subsets[subsetIndex]; + ASSERT(subset != NULL); + + VertexBuffer *vertices = subset->GetVertices(); + uint32_t bufferIndex = triangle * 3; + + ASSERT((bufferIndex + 3) <= vertices->GetNumElements()); + + SetTriangleInternal( + vertices, bufferIndex, + v1, v2, v3, + t1, t2, t3 + ); +} + +void StaticMeshBuilder::SetQuad( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, const Vector3 &v4, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, const Vector3 &n4, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3, const Vector2 &t4 + ) +{ + STACK_TRACE; + ASSERT(m_subsets.size() > subsetIndex); + + StaticMeshSubset *subset = m_subsets[subsetIndex]; + ASSERT(subset != NULL); + + VertexBuffer *vertices = subset->GetVertices(); + uint32_t bufferIndex = firstTriangle * 3; + + ASSERT((bufferIndex + 6) <= vertices->GetNumElements()); + + SetTriangleInternal( + vertices, bufferIndex, + v1, v2, v3, + n1, n2, n3, + t1, t2, t3 + ); + SetTriangleInternal( + vertices, bufferIndex + 3, + v2, v4, v3, + n2, n4, n3, + t2, t4, t3 + ); +} + +void StaticMeshBuilder::SetQuad( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, const Vector3 &v4, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3, const Vector2 &t4 + ) +{ + STACK_TRACE; + ASSERT(m_subsets.size() > subsetIndex); + + StaticMeshSubset *subset = m_subsets[subsetIndex]; + ASSERT(subset != NULL); + + VertexBuffer *vertices = subset->GetVertices(); + uint32_t bufferIndex = firstTriangle * 3; + + ASSERT((bufferIndex + 6) <= vertices->GetNumElements()); + + SetTriangleInternal( + vertices, bufferIndex, + v1, v2, v3, + t1, t2, t3 + ); + SetTriangleInternal( + vertices, bufferIndex + 3, + v2, v4, v3, + t2, t4, t3 + ); +} + +void StaticMeshBuilder::SetBox( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 ¢er, float width, float height, float depth + ) +{ + STACK_TRACE; + ASSERT(width > 0.0f); + ASSERT(height > 0.0f); + ASSERT(depth > 0.0f); + + float halfWidth = width / 2.0f; + float halfHeight = height / 2.0f; + float halfDepth = depth / 2.0f; + + Vector3 min = Vector3(center.x - halfWidth, center.y - halfHeight, center.z - halfDepth); + Vector3 max = Vector3(center.x + halfWidth, center.y + halfHeight, center.z + halfDepth); + + SetBox(subsetIndex, firstTriangle, min, max); +} + +void StaticMeshBuilder::SetBox( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &min, const Vector3 &max + ) +{ + STACK_TRACE; + // front + SetQuad( + subsetIndex, firstTriangle, + Vector3(min.x, min.y, max.z), Vector3(max.x, min.y, max.z), Vector3(min.x, max.y, max.z), Vector3(max.x, max.y, max.z), + Z_AXIS, Z_AXIS, Z_AXIS, Z_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); + + // back + SetQuad( + subsetIndex, firstTriangle + 2, + Vector3(max.x, min.y, min.z), Vector3(min.x, min.y, min.z), Vector3(max.x, max.y, min.z), Vector3(min.x, max.y, min.z), + -Z_AXIS, -Z_AXIS, -Z_AXIS, -Z_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); + + // right + SetQuad( + subsetIndex, firstTriangle + 4, + Vector3(max.x, min.y, max.z), Vector3(max.x, min.y, min.z), Vector3(max.x, max.y, max.z), Vector3(max.x, max.y, min.z), + X_AXIS, X_AXIS, X_AXIS, X_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); + + // left + SetQuad( + subsetIndex, firstTriangle + 6, + Vector3(min.x, min.y, min.z), Vector3(min.x, min.y, max.z), Vector3(min.x, max.y, min.z), Vector3(min.x, max.y, max.z), + -X_AXIS, -X_AXIS, -X_AXIS, -X_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); + + // top + SetQuad( + subsetIndex, firstTriangle + 8, + Vector3(min.x, max.y, max.z), Vector3(max.x, max.y, max.z), Vector3(min.x, max.y, min.z), Vector3(max.x, max.y, min.z), + Y_AXIS, Y_AXIS, Y_AXIS, Y_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); + + // bottom + SetQuad( + subsetIndex, firstTriangle + 10, + Vector3(max.x, min.y, max.z), Vector3(min.x, min.y, max.z), Vector3(max.x, min.y, min.z), Vector3(min.x, min.y, min.z), + -Y_AXIS, -Y_AXIS, -Y_AXIS, -Y_AXIS, + Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 0.0f) + ); +} + +void StaticMeshBuilder::GenerateNormals() +{ + STACK_TRACE; + ASSERT(m_subsets.size() > 0); + + for (uint32_t i = 0; i < m_subsets.size(); ++i) + { + StaticMeshSubset *subset = m_subsets[i]; + ASSERT(subset != NULL); + + VertexBuffer *buffer = subset->GetVertices(); + ASSERT(buffer->GetNumElements() % 3 == 0); + + // initialize all normals + for (uint32_t n = 0; n < buffer->GetNumElements(); ++n) + buffer->SetNormal(n, 0.0f, 0.0f, 0.0f); + + // calculate the normal for each triangle and add it to the normals for each individual vertex + for (uint32_t v = 0; v < buffer->GetNumElements() / 3; ++v) + { + // calculate the triangle normal + // they should have been added in CCW order (which StaticMeshBuilder does...) + Vector3 a = buffer->GetPosition3(v * 3); + Vector3 b = buffer->GetPosition3((v * 3) + 1); + Vector3 c = buffer->GetPosition3((v * 3) + 2); + Vector3 triangleNormal = Vector3::SurfaceNormal(a, b, c); + + // add it to the vertex normals for this triangle + Vector3 na = buffer->GetNormal(v * 3); + Vector3 nb = buffer->GetNormal((v * 3) + 1); + Vector3 nc = buffer->GetNormal((v * 3) + 2); + buffer->SetNormal(v * 3, na + triangleNormal); + buffer->SetNormal((v * 3) + 1, nb + triangleNormal); + buffer->SetNormal((v * 3) + 2, nc + triangleNormal); + } + + // all the vertex normals will be way too long, need to normalize all of them now + for (uint32_t n = 0; n < buffer->GetNumElements(); ++n) + { + Vector3 normal = buffer->GetNormal(n); + buffer->SetNormal(n, Vector3::Normalize(normal)); + } + } +} + +StaticMesh* StaticMeshBuilder::BuildMesh() +{ + STACK_TRACE; + ASSERT(m_subsets.size() > 0); + + // convert the mesh vector to an array so it can be passed into the mesh object + StaticMeshSubset **subsets = new StaticMeshSubset*[m_subsets.size()]; + ASSERT(subsets != NULL); + for (uint32_t i = 0; i < m_subsets.size(); ++i) + subsets[i] = m_subsets[i]; + + StaticMesh *mesh = new StaticMesh(m_subsets.size(), subsets); + + // the new StaticMesh object has now assumed responsibility for cleaning + // up the memory allocated to the StaticMeshSubsets we passed to it. + // remove the references we have to those objects so we don't delete the + // memory twice accidentally + Reset(); + + return mesh; +} + +void StaticMeshBuilder::SetTriangleInternal( + VertexBuffer *buffer, + uint32_t bufferIndex, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ) +{ + buffer->SetPosition3(bufferIndex, v1 * m_transform); + buffer->SetNormal(bufferIndex, n1); + buffer->SetTexCoord(bufferIndex, t1); + + buffer->SetPosition3(bufferIndex + 1, v2 * m_transform); + buffer->SetNormal(bufferIndex + 1, n2); + buffer->SetTexCoord(bufferIndex + 1, t2); + + buffer->SetPosition3(bufferIndex + 2, v3 * m_transform); + buffer->SetNormal(bufferIndex + 2, n3); + buffer->SetTexCoord(bufferIndex + 2, t3); +} + +void StaticMeshBuilder::SetTriangleInternal( + VertexBuffer *buffer, + uint32_t bufferIndex, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ) +{ + buffer->SetPosition3(bufferIndex, v1 * m_transform); + buffer->SetTexCoord(bufferIndex, t1); + + buffer->SetPosition3(bufferIndex + 1, v2 * m_transform); + buffer->SetTexCoord(bufferIndex + 1, t2); + + buffer->SetPosition3(bufferIndex + 2, v3 * m_transform); + buffer->SetTexCoord(bufferIndex + 2, t3); +} diff --git a/src/framework/assets/static/staticmeshbuilder.h b/src/framework/assets/static/staticmeshbuilder.h new file mode 100644 index 0000000..c838f82 --- /dev/null +++ b/src/framework/assets/static/staticmeshbuilder.h @@ -0,0 +1,165 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHBUILDER_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHBUILDER_H_INCLUDED__ + +#include "../../common.h" + +#include "../../math/matrix4x4.h" + +#include + +class StaticMesh; +class StaticMeshSubset; +class Texture; +class VertexBuffer; +struct Vector2; +struct Vector3; + +/** + * Helper class to simplify the task of dynamically building up a StaticMesh + * object via code. + */ +class StaticMeshBuilder +{ +public: + /** + * Creates a static mesh builder. + */ + StaticMeshBuilder(); + + virtual ~StaticMeshBuilder(); + + /** + * Resets all generated subset information, clearing out all information + * so this builder is ready to generate a new mesh from scratch. + */ + void Reset(); + + /** + * Sets a transformation matrix that every subsequently generated vertex + * will have applied to it. + * @param transform the transformation matrix + */ + void SetTransform(const Matrix4x4 &transform) { m_transform = transform; } + + /** + * Adds a new subset to the mesh currently being generated. + * @param numTriangles the number of triangles in this subset + * @param texture the texture to be applied to this subset, or NULL to use + * no texture with it + */ + uint32_t AddSubset(uint32_t numTriangles, Texture *texture); + + /** + * Sets a triangle on the specified subset. + * @param subsetIndex the index of the subset to set the triangle on + * @param triangle the index of the triangle to set in the subset + */ + void SetTriangle( + uint32_t subsetIndex, + uint32_t triangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ); + + /** + * Sets a triangle on the specified subset. + * @param subsetIndex the index of the subset to set the triangle on + * @param triangle the index of the triangle to set in the subset + */ + void SetTriangle( + uint32_t subsetIndex, + uint32_t triangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ); + + /** + * Sets a quad on the specified subset. This is generated as two + * triangles. + * @param subsetIndex the index of the subset to set the quad on + * @param firstTriangle the index of the first triangle of two that + * the quad's vertices will be set in + */ + void SetQuad( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, const Vector3 &v4, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, const Vector3 &n4, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3, const Vector2 &t4 + ); + + /** + * Sets a quad on the specified subset. This is generated as two + * triangles. + * @param subsetIndex the index of the subset to set the quad on + * @param firstTriangle the index of the first triangle of two that + * the quad's vertices will be set in + */ + void SetQuad( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, const Vector3 &v4, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3, const Vector2 &t4 + ); + + /** + * Sets a box on the specified subset. This is generated as 12 + * triangles. + * @param subsetIndex the index of the subset to set the box on + * @param firstTriangle the index of the first triangle of two that + * the box's vertices will be set in + */ + void SetBox( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 ¢er, float width, float height, float depth + ); + + /** + * Sets a box on the specified subset. This is generated as 12 + * triangles. + * @param subsetIndex the index of the subset to set the box on + * @param firstTriangle the index of the first triangle of two that + * the box's vertices will be set in + */ + void SetBox( + uint32_t subsetIndex, + uint32_t firstTriangle, + const Vector3 &min, const Vector3 &max + ); + + /** + * Automatically generates normals for every vertex in all subsets. This + * will overwrite any normals that may have been directly provided already. + */ + void GenerateNormals(); + + /** + * Constructs a StaticMesh object, returns it, then frees the subsets from + * the builder so that it is ready for use in generating another mesh. The + * returned mesh should be manually freed by the calling code when no + * longer needed. + */ + StaticMesh* BuildMesh(); + +private: + void SetTriangleInternal( + VertexBuffer *buffer, + uint32_t bufferIndex, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector3 &n1, const Vector3 &n2, const Vector3 &n3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ); + void SetTriangleInternal( + VertexBuffer *buffer, + uint32_t bufferIndex, + const Vector3 &v1, const Vector3 &v2, const Vector3 &v3, + const Vector2 &t1, const Vector2 &t2, const Vector2 &t3 + ); + + Matrix4x4 m_transform; + stl::vector m_subsets; +}; + +#endif diff --git a/src/framework/assets/static/staticmeshfile.cpp b/src/framework/assets/static/staticmeshfile.cpp new file mode 100644 index 0000000..6102341 --- /dev/null +++ b/src/framework/assets/static/staticmeshfile.cpp @@ -0,0 +1,140 @@ +#include "../../debug.h" + +#include "staticmeshfile.h" + +#include "staticmeshtriangle.h" +#include "../../file/file.h" +#include "../../math/vector3.h" +#include "../../math/vector2.h" + +StaticMeshFile::StaticMeshFile(File *file) + : MeshFile(file) +{ + STACK_TRACE; + m_vertices = NULL; + m_normals = NULL; + m_texCoords = NULL; + m_materials = NULL; + m_triangles = NULL; + m_subMeshes = NULL; + m_numVertices = 0; + m_numNormals = 0; + m_numTexCoords = 0; + m_numMaterials = 0; + m_numTriangles = 0; + m_numSubMeshes = 0; + Load(); +} + +StaticMeshFile::~StaticMeshFile() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_vertices); + SAFE_DELETE_ARRAY(m_normals); + SAFE_DELETE_ARRAY(m_texCoords); + SAFE_DELETE_ARRAY(m_materials); + SAFE_DELETE_ARRAY(m_triangles); + SAFE_DELETE_ARRAY(m_subMeshes); +} + +void StaticMeshFile::Load() +{ + STACK_TRACE; + ChunkDescriptor *verticesDesc = GetChunkDesc("VTX"); + ChunkDescriptor *normalsDesc = GetChunkDesc("NRL"); + ChunkDescriptor *texCoordsDesc = GetChunkDesc("TXT"); + ChunkDescriptor *materialsDesc = GetChunkDesc("MTL"); + ChunkDescriptor *trianglesDesc = GetChunkDesc("TRI"); + ChunkDescriptor *subMeshesDesc = GetChunkDesc("GRP"); + ASSERT(verticesDesc != NULL); + ASSERT(materialsDesc != NULL); + ASSERT(trianglesDesc != NULL); + ASSERT(subMeshesDesc != NULL); + + File *file = GetFile(); + + // vertices + file->Seek(verticesDesc->start, FILESEEK_BEGINNING); + m_numVertices = file->ReadUnsignedInt(); + m_vertices = new Vector3[m_numVertices]; + ASSERT(m_vertices != NULL); + for (uint32_t i = 0; i < m_numVertices; ++i) + { + m_vertices[i].x = file->ReadFloat(); + m_vertices[i].y = file->ReadFloat(); + m_vertices[i].z = file->ReadFloat(); + } + + // normals + if (normalsDesc != NULL) + { + file->Seek(normalsDesc->start, FILESEEK_BEGINNING); + m_numNormals = file->ReadUnsignedInt(); + m_normals = new Vector3[m_numNormals]; + ASSERT(m_normals != NULL); + for (uint32_t i = 0; i < m_numNormals; ++i) + { + m_normals[i].x = file->ReadFloat(); + m_normals[i].y = file->ReadFloat(); + m_normals[i].z = file->ReadFloat(); + } + } + + // texture coordinates + if (texCoordsDesc != NULL) + { + file->Seek(texCoordsDesc->start, FILESEEK_BEGINNING); + m_numTexCoords = file->ReadUnsignedInt(); + m_texCoords = new Vector2[m_numTexCoords]; + ASSERT(m_texCoords != NULL); + for (uint32_t i = 0; i < m_numTexCoords; ++i) + { + m_texCoords[i].x = file->ReadFloat(); + m_texCoords[i].y = file->ReadFloat(); + } + } + + // materials chunk + file->Seek(materialsDesc->start, FILESEEK_BEGINNING); + m_numMaterials = file->ReadUnsignedInt(); + m_materials = new StaticMeshFileMaterial[m_numMaterials]; + ASSERT(m_materials != NULL); + for (uint32_t i = 0; i < m_numMaterials; ++i) + { + StaticMeshFileMaterial *material = &m_materials[i]; + + file->ReadString(material->name); + file->ReadString(material->textureFile); + + // TODO: read and store the rest of the material somewhere. skip for now + file->Seek(sizeof(float) * 14, FILESEEK_CURRENT); + } + + // triangles + file->Seek(trianglesDesc->start, FILESEEK_BEGINNING); + m_numTriangles = file->ReadUnsignedInt(); + m_triangles = new StaticMeshTriangle[m_numTriangles]; + ASSERT(m_triangles != NULL); + for (uint32_t i = 0; i < m_numTriangles; ++i) + { + m_triangles[i].vertices[0] = file->ReadUnsignedInt(); + m_triangles[i].vertices[1] = file->ReadUnsignedInt(); + m_triangles[i].vertices[2] = file->ReadUnsignedInt(); + + m_triangles[i].subMeshIndex = file->ReadUnsignedInt(); + } + + // sub meshes chunk + file->Seek(subMeshesDesc->start, FILESEEK_BEGINNING); + m_numSubMeshes = file->ReadUnsignedInt(); + m_subMeshes = new StaticMeshFileSubMesh[m_numSubMeshes]; + ASSERT(m_subMeshes != NULL); + for (uint32_t i = 0; i < m_numSubMeshes; ++i) + { + StaticMeshFileSubMesh *subMesh = &m_subMeshes[i]; + + file->ReadString(subMesh->name); + subMesh->material = file->ReadUnsignedInt(); + subMesh->numTriangles = file->ReadUnsignedInt(); + } +} diff --git a/src/framework/assets/static/staticmeshfile.h b/src/framework/assets/static/staticmeshfile.h new file mode 100644 index 0000000..739c184 --- /dev/null +++ b/src/framework/assets/static/staticmeshfile.h @@ -0,0 +1,126 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHFILE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHFILE_H_INCLUDED__ + +#include "../../common.h" + +#include + +#include "../meshfile.h" + +class File; +struct StaticMeshTriangle; +struct Vector2; +struct Vector3; + +/** + * Holds information about materials in a static mesh file. + */ +struct StaticMeshFileMaterial +{ + stl::string name; + stl::string textureFile; +}; + +/** + * Holds information about sub-meshes (subsets) in a static mesh file. + */ +struct StaticMeshFileSubMesh +{ + stl::string name; + uint32_t material; + uint32_t numTriangles; +}; + +/** + * A static mesh file which is loaded using a custom "chunked" file format. + */ +class StaticMeshFile : public MeshFile +{ +public: + /** + * Creates a static mesh file object by loading the mesh information + * from the provided file. + * @param file the file that will be loaded as a static mesh + */ + StaticMeshFile(File *file); + + virtual ~StaticMeshFile(); + + /** + * @return the total number of vertices this mesh contains + */ + uint32_t GetNumVertices() const { return m_numVertices; } + + /** + * @return pointer to the mesh's vertex data + */ + Vector3* GetVertices() const { return m_vertices; } + + /** + * @return the total number of normals this mesh contains + */ + uint32_t GetNumNormals() const { return m_numNormals; } + + /** + * @return pointer to the mesh's normal data, or NULL if none exist + */ + Vector3* GetNormals() const { return m_normals; } + + /** + * @return the total number of texture coordinates this mesh contains + */ + uint32_t GetNumTexCoords() const { return m_numTexCoords; } + + /** + * @return pointer to the mesh's texture coordinates, or NULL if none exist + */ + Vector2* GetTexCoords() const { return m_texCoords; } + + /** + * @return the total number of materials that this mesh contains + */ + uint32_t GetNumMaterials() const { return m_numMaterials; } + + /** + * @return pointer to the mesh's materials + */ + StaticMeshFileMaterial* GetMaterials() const { return m_materials; } + + /** + * @return the total number of triangles that this mesh contains + */ + uint32_t GetNumTriangles() const { return m_numTriangles; } + + /** + * @return pointer to the mesh's triangles + */ + StaticMeshTriangle* GetTriangles() const { return m_triangles; } + + /** + * @return the total number of sub-meshes (subsets) this mesh contains + */ + uint32_t GetNumSubMeshes() const { return m_numSubMeshes; } + + /** + * @return pointer to the mesh's sub-meshes (subsets) + */ + StaticMeshFileSubMesh* GetSubMeshes() const { return m_subMeshes; } + +private: + void Load(); + + uint32_t m_numVertices; + Vector3 *m_vertices; + uint32_t m_numNormals; + Vector3 *m_normals; + uint32_t m_numTexCoords; + Vector2 *m_texCoords; + uint32_t m_numMaterials; + StaticMeshFileMaterial *m_materials; + uint32_t m_numTriangles; + StaticMeshTriangle *m_triangles; + uint32_t m_numSubMeshes; + StaticMeshFileSubMesh *m_subMeshes; +}; + +#endif diff --git a/src/framework/assets/static/staticmeshinstance.cpp b/src/framework/assets/static/staticmeshinstance.cpp new file mode 100644 index 0000000..7cc722c --- /dev/null +++ b/src/framework/assets/static/staticmeshinstance.cpp @@ -0,0 +1,48 @@ +#include "../../debug.h" + +#include "staticmeshinstance.h" + +#include "staticmesh.h" +#include "staticmeshsubset.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/texture.h" + +StaticMeshInstance::StaticMeshInstance(StaticMesh *mesh) +{ + STACK_TRACE; + m_mesh = mesh; + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + + // prepare list of local mesh instance texture overrides + // initialize it as an exact copy of the source mesh's textures + m_textures = NULL; + if (m_mesh->GetNumSubsets() > 0) + { + m_textures = new Texture*[m_mesh->GetNumSubsets()]; + ASSERT(m_textures != NULL); + + for (uint32_t i = 0; i < m_mesh->GetNumSubsets(); ++i) + ResetTexture(i); + } +} + +StaticMeshInstance::~StaticMeshInstance() +{ + STACK_TRACE; + SAFE_DELETE(m_renderState); +} + +void StaticMeshInstance::SetTexture(uint32_t index, Texture *texture) +{ + STACK_TRACE; + m_textures[index] = texture; +} + +void StaticMeshInstance::ResetTexture(uint32_t index) +{ + STACK_TRACE; + m_textures[index] = m_mesh->GetSubset(index)->GetTexture(); +} + diff --git a/src/framework/assets/static/staticmeshinstance.h b/src/framework/assets/static/staticmeshinstance.h new file mode 100644 index 0000000..467ad9e --- /dev/null +++ b/src/framework/assets/static/staticmeshinstance.h @@ -0,0 +1,71 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHINSTANCE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHINSTANCE_H_INCLUDED__ + +#include "../../common.h" + +#include "staticmesh.h" + +class RenderState; +class Texture; + +/** + * An instance of a static mesh that can be manipulated and rendered from + * a single shared mesh object. + */ +class StaticMeshInstance +{ +public: + /** + * Creates a new static mesh instance. + * @param mesh the mesh this instance is of + */ + StaticMeshInstance(StaticMesh *mesh); + + virtual ~StaticMeshInstance(); + + /** + * @return the render state used to render this instance + */ + RenderState* GetRenderState() const { return m_renderState; } + + /** + * @return the mesh this instance is of + */ + StaticMesh* GetMesh() const { return m_mesh; } + + /** + * @return the number of textures/materials that the mesh this instance + * is for contains + */ + uint32_t GetNumTextures() const { return m_mesh->GetNumSubsets(); } + + /** + * Gets the texture for the specified subset/material. + * @param index the index of the specified subset/material to get the + * texture for + * @return the texture, or NULL if one is not set + */ + Texture* GetTexture(uint32_t index) const { return m_textures[index]; } + + /** + * Sets a new texture for the specified subset/material. + * @param index the index of the subset/material to change the texture for + * @param texture the new texture to set, or NULL to set no texture + */ + void SetTexture(uint32_t index, Texture *texture); + + /** + * Resets the texture for the specified subset/material back to the mesh's + * original texture. + * @param index the index of the subset/material to reset the texture for + */ + void ResetTexture(uint32_t index); + +private: + StaticMesh *m_mesh; + RenderState *m_renderState; + + Texture **m_textures; +}; + +#endif diff --git a/src/framework/assets/static/staticmeshrenderer.cpp b/src/framework/assets/static/staticmeshrenderer.cpp new file mode 100644 index 0000000..100d122 --- /dev/null +++ b/src/framework/assets/static/staticmeshrenderer.cpp @@ -0,0 +1,65 @@ +#include "../../debug.h" + +#include "staticmeshrenderer.h" + +#include "staticmesh.h" +#include "staticmeshinstance.h" +#include "staticmeshsubset.h" +#include "../../graphics/graphicsdevice.h" +#include "../../graphics/texture.h" +#include "../../graphics/renderstate.h" +#include "../../graphics/vertexbuffer.h" + +StaticMeshRenderer::StaticMeshRenderer() +{ + STACK_TRACE; +} + +StaticMeshRenderer::~StaticMeshRenderer() +{ + STACK_TRACE; +} + +void StaticMeshRenderer::Render(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance) +{ + STACK_TRACE; + instance->GetRenderState()->Apply(); + + if (instance->GetNumTextures() > 0) + RenderAllSubsets(graphicsDevice, instance); + else + RenderAllSubsetsTextureless(graphicsDevice, instance); +} + +void StaticMeshRenderer::RenderAllSubsets(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance) +{ + STACK_TRACE; + for (uint32_t i = 0; i < instance->GetMesh()->GetNumSubsets(); ++i) + RenderSubset(graphicsDevice, instance->GetMesh()->GetSubset(i), instance->GetTexture(i)); +} + +void StaticMeshRenderer::RenderAllSubsetsTextureless(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance) +{ + STACK_TRACE; + for (uint32_t i = 0; i < instance->GetMesh()->GetNumSubsets(); ++i) + RenderTexturelessSubset(graphicsDevice, instance->GetMesh()->GetSubset(i)); +} + +void StaticMeshRenderer::RenderSubset(GraphicsDevice *graphicsDevice, const StaticMeshSubset *subset, const Texture *texture) +{ + STACK_TRACE; + if (texture != NULL) + graphicsDevice->BindTexture(texture); + graphicsDevice->BindVertexBuffer(subset->GetVertices()); + graphicsDevice->RenderTriangles(); + graphicsDevice->UnbindVertexBuffer(); +} + +void StaticMeshRenderer::RenderTexturelessSubset(GraphicsDevice *graphicsDevice, const StaticMeshSubset *subset) +{ + STACK_TRACE; + graphicsDevice->BindVertexBuffer(subset->GetVertices()); + graphicsDevice->RenderTriangles(); + graphicsDevice->UnbindVertexBuffer(); +} + diff --git a/src/framework/assets/static/staticmeshrenderer.h b/src/framework/assets/static/staticmeshrenderer.h new file mode 100644 index 0000000..c8fd1ce --- /dev/null +++ b/src/framework/assets/static/staticmeshrenderer.h @@ -0,0 +1,39 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHRENDERER_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHRENDERER_H_INCLUDED__ + +#include "../../common.h" + +class GraphicsDevice; +class StaticMeshInstance; +class StaticMeshSubset; +class Texture; + +/** + * Helper object that renders instances of static mesh objects. + */ +class StaticMeshRenderer +{ +public: + /** + * Creates a static mesh renderer. + */ + StaticMeshRenderer(); + + virtual ~StaticMeshRenderer(); + + /** + * Renders an instance of a static mesh. + * @param graphicsDevice the graphics device to render with + * @param instance the static mesh instance to render + */ + void Render(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance); + +private: + void RenderAllSubsets(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance); + void RenderAllSubsetsTextureless(GraphicsDevice *graphicsDevice, StaticMeshInstance *instance); + + void RenderSubset(GraphicsDevice *graphicsDevice, const StaticMeshSubset *subset, const Texture *texture); + void RenderTexturelessSubset(GraphicsDevice *graphicsDevice, const StaticMeshSubset *subset); +}; + +#endif diff --git a/src/framework/assets/static/staticmeshsubset.cpp b/src/framework/assets/static/staticmeshsubset.cpp new file mode 100644 index 0000000..fb0ceb8 --- /dev/null +++ b/src/framework/assets/static/staticmeshsubset.cpp @@ -0,0 +1,24 @@ +#include "../../debug.h" + +#include "staticmeshsubset.h" + +#include "../../graphics/texture.h" +#include "../../graphics/vertexbuffer.h" + +StaticMeshSubset::StaticMeshSubset(uint32_t numTriangles, Texture *texture) +{ + STACK_TRACE; + m_vertices = new VertexBuffer(BUFFEROBJECT_USAGE_STATIC); + ASSERT(m_vertices != NULL); + m_vertices->AddAttribute(VERTEX_POS_3D); + m_vertices->AddAttribute(VERTEX_NORMAL); + m_vertices->AddAttribute(VERTEX_TEXCOORD); + m_vertices->Create(numTriangles * 3); + m_texture = texture; +} + +StaticMeshSubset::~StaticMeshSubset() +{ + STACK_TRACE; + SAFE_DELETE(m_vertices); +} diff --git a/src/framework/assets/static/staticmeshsubset.h b/src/framework/assets/static/staticmeshsubset.h new file mode 100644 index 0000000..d780b80 --- /dev/null +++ b/src/framework/assets/static/staticmeshsubset.h @@ -0,0 +1,41 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHSUBSET_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHSUBSET_H_INCLUDED__ + +#include "../../common.h" + +class Texture; +class VertexBuffer; + +/** + * Contains vertex and texture information for a single static mesh + * sub-mesh (subset). + */ +class StaticMeshSubset +{ +public: + /** + * Creates a static mesh subset. + * @param numTriangles the number of triangles this subset will contain + * @param texture the texture to be applied to this subset + */ + StaticMeshSubset(uint32_t numTriangles, Texture *texture); + + virtual ~StaticMeshSubset(); + + /** + * @return the vertices contained in this subset + */ + VertexBuffer* GetVertices() const { return m_vertices; } + + /** + * @return the texture applied to this subset, or NULL if no texture is set + */ + Texture* GetTexture() const { return m_texture; } + +private: + VertexBuffer *m_vertices; + Texture *m_texture; +}; + + +#endif diff --git a/src/framework/assets/static/staticmeshtriangle.h b/src/framework/assets/static/staticmeshtriangle.h new file mode 100644 index 0000000..7241186 --- /dev/null +++ b/src/framework/assets/static/staticmeshtriangle.h @@ -0,0 +1,15 @@ +#ifndef __FRAMEWORK_ASSETS_STATIC_STATICMESHTRIANGLE_H_INCLUDED__ +#define __FRAMEWORK_ASSETS_STATIC_STATICMESHTRIANGLE_H_INCLUDED__ + +#include "../../common.h" + +/** + * Contains vertex and sub-mesh indices for a triangle in a static mesh. + */ +struct StaticMeshTriangle +{ + uint32_t vertices[3]; + uint32_t subMeshIndex; +}; + +#endif diff --git a/src/framework/basegameapp.cpp b/src/framework/basegameapp.cpp new file mode 100644 index 0000000..33699b9 --- /dev/null +++ b/src/framework/basegameapp.cpp @@ -0,0 +1,316 @@ +#include "debug.h" +#include "log.h" + +#include "basegameapp.h" + +#include "operatingsystem.h" +#include "gamewindow.h" +#include "content/contentmanager.h" +#include "file/util.h" +#include "graphics/glincludes.h" +#include "graphics/graphicsdevice.h" +#include "input/keyboard.h" +#include "input/mouse.h" +#include "input/touchscreen.h" + +const uint32_t DEFAULT_UPDATE_FREQUENCY = 60; +const uint32_t DEFAULT_MAX_FRAMESKIP = 10; + +BaseGameApp::BaseGameApp() +{ + STACK_TRACE; + m_stop = FALSE; + m_isPaused = FALSE; + m_fps = 0; + m_frameTime = 0.0f; + m_numRenders = 0; + m_rendersPerSecond = 0; + m_numUpdates = 0; + m_updatesPerSecond = 0; + m_renderTime = 0; + m_updateTime = 0; + m_nextUpdateAt = 0; + m_isRunningSlowly = FALSE; + m_isDirty = FALSE; + m_system = NULL; + m_window = NULL; + m_graphics = NULL; + m_content = NULL; + + SetUpdateFrequency(DEFAULT_UPDATE_FREQUENCY); + SetMaxFrameSkip(DEFAULT_MAX_FRAMESKIP); +} + +BaseGameApp::~BaseGameApp() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Releasing.\n"); + if (m_graphics != NULL) + OnLostContext(); + + SAFE_DELETE(m_content); + SAFE_DELETE(m_graphics); +} + +BOOL BaseGameApp::Start(OperatingSystem *system) +{ + STACK_TRACE; + m_system = system; + + LOG_INFO(LOGCAT_GAMEAPP, "Starting.\n"); + if (!OnInit()) + { + LOG_ERROR(LOGCAT_GAMEAPP, "Initialization failed.\n"); + return FALSE; + } + LOG_INFO(LOGCAT_GAMEAPP, "Initialization succeeded.\n"); + OnNewContext(); + OnResize(); + + return TRUE; +} + +BOOL BaseGameApp::Initialize(GameWindowParams *windowParams) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Starting initialization.\n"); + + if (!m_system->CreateGameWindow(this, windowParams)) + return FALSE; + + LOG_INFO(LOGCAT_GAMEAPP, "Verifying shader support present.\n"); + if (!m_system->HasShaderSupport()) + { + LOG_ERROR(LOGCAT_GAMEAPP, "No support for shaders detected. Graphics framework requires hardware shader support. Aborting.\n"); + return FALSE; + } + + m_window = m_system->GetWindow(); + if (m_window == NULL) + { + LOG_ERROR(LOGCAT_GAMEAPP, "Not able to get a GameWindow instance.\n"); + return FALSE; + } + + m_graphics = new GraphicsDevice(m_window); + ASSERT(m_graphics != NULL); + + m_content = new ContentManager(this); + ASSERT(m_content != NULL); + + LOG_INFO(LOGCAT_GAMEAPP, "Initialization finished.\n"); + + return TRUE; +} + +void BaseGameApp::Loop() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "OnLoadGame event.\n"); + m_content->OnLoadGame(); + OnLoadGame(); + + LOG_INFO(LOGCAT_GAMEAPP, "Main loop started.\n"); + + uint32_t numUpdatesThisFrame; + uint32_t numLoops = 0; + uint32_t timeElapsed = 0; + + uint32_t updateTime = 0; + uint32_t renderTime = 0; + + m_nextUpdateAt = GetTicks(); + uint32_t currentTime = GetTicks(); + + while (!m_stop) + { + if (m_isPaused) + { + // make sure we *always* do our own internal processing all the time + // that this loop is being executed. this makes sure OS events are + // being processed. + // NOTE: the underlying framework may or may not keep this loop running + // when the app has been paused however. + InternalUpdate(); + } + else + { + uint32_t newTime = GetTicks(); + uint32_t frameTime = newTime - currentTime; + currentTime = newTime; + timeElapsed += frameTime; + + // Every second, recalculate the FPS + if (timeElapsed >= 1000) + { + m_fps = numLoops; + m_frameTime = 1000.0f / m_fps; + + m_rendersPerSecond = m_numRenders; + m_updatesPerSecond = m_numUpdates; + m_renderTime = renderTime; + m_updateTime = updateTime; + + m_numUpdates = 0; + m_numRenders = 0; + renderTime = 0; + updateTime = 0; + + numLoops = 0; + timeElapsed = 0; + } + + // we're "running slowly" if we're more than one update behind + if (currentTime > m_nextUpdateAt + m_ticksPerUpdate) + m_isRunningSlowly = TRUE; + else + m_isRunningSlowly = FALSE; + + numUpdatesThisFrame = 0; + while (GetTicks() >= m_nextUpdateAt && numUpdatesThisFrame < m_maxFrameSkip) + { + if (numUpdatesThisFrame > 0) + m_isRunningSlowly = TRUE; + + uint32_t before = GetTicks(); + OnUpdate(m_fixedUpdateInterval); + updateTime += GetTicks() - before; + + ++numUpdatesThisFrame; + m_nextUpdateAt += m_ticksPerUpdate; + + ++m_numUpdates; + + // just updated, so we need to render the new game state + m_isDirty = TRUE; + } + + if (m_isDirty && m_window->IsActive() && m_window->HasGLContext()) + { + uint32_t before = GetTicks(); + OnRender(); + m_window->Flip(); + renderTime += GetTicks() - before; + + ++m_numRenders; + + // don't render again until we have something new to show + m_isDirty = FALSE; + } + + ++numLoops; + } + } + + LOG_INFO(LOGCAT_GAMEAPP, "Main loop exiting.\n"); +} + +void BaseGameApp::Quit() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Quit requested.\n"); + if (!m_system->IsQuitting()) + m_system->Quit(); + m_stop = TRUE; +} + +void BaseGameApp::OnAppGainFocus() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Gained focus.\n"); +} + +void BaseGameApp::OnAppLostFocus() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Lost focus.\n"); +} + +void BaseGameApp::OnAppPause() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Paused.\n"); + m_isPaused = TRUE; +} + +void BaseGameApp::OnAppResume() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Resumed.\n"); + m_isPaused = FALSE; + + // this makes it so that the main loop won't try to "catch up" thinking that + // it's really far behind with updates since m_nextUpdateAt won't have been + // updated since before the app was paused. + m_nextUpdateAt = GetTicks(); +} + +void BaseGameApp::OnLostContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Lost OpenGL context.\n"); + + if (m_graphics != NULL) + m_graphics->OnLostContext(); + if (m_content != NULL) + m_content->OnLostContext(); +} + +void BaseGameApp::OnNewContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "New OpenGL context.\n"); + m_graphics->OnNewContext(); + m_content->OnNewContext(); + + // ensure we render an initial view for the new context + Invalidate(); +} + +void BaseGameApp::OnRender() +{ + STACK_TRACE; + m_graphics->OnRender(); +} + +void BaseGameApp::OnResize() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GAMEAPP, "Window resize complete.\n"); + m_graphics->OnResize(m_window->GetRect()); + + // ensure we render to initially fit the new window size + Invalidate(); +} + +void BaseGameApp::InternalUpdate() +{ + STACK_TRACE; + m_system->ProcessEvents(); + + if (m_window->IsClosing() && !m_stop) + Quit(); +} + +void BaseGameApp::OnUpdate(float delta) +{ + STACK_TRACE; + InternalUpdate(); +} + +void BaseGameApp::SetUpdateFrequency(uint32_t targetFrequency) +{ + STACK_TRACE; + m_targetUpdatesPerSecond = targetFrequency; + m_ticksPerUpdate = 1000 / m_targetUpdatesPerSecond; + m_fixedUpdateInterval = m_ticksPerUpdate / 1000.0f; +} + +BOOL BaseGameApp::IsAppFocused() const +{ + STACK_TRACE; + if (m_window != NULL) + return m_window->IsFocused(); + else + return FALSE; // if there's no window, it can't be focused! +} diff --git a/src/framework/basegameapp.h b/src/framework/basegameapp.h new file mode 100644 index 0000000..36584e8 --- /dev/null +++ b/src/framework/basegameapp.h @@ -0,0 +1,239 @@ +#ifndef __FRAMEWORK_BASEGAMEAPP_H_INCLUDED__ +#define __FRAMEWORK_BASEGAMEAPP_H_INCLUDED__ + +#include "common.h" + +#include "operatingsystem.h" + +class ContentManager; +class GameWindow; +class GraphicsDevice; +class Keyboard; +class Mouse; +class OperatingSystem; +class Touchscreen; +struct GameWindowParams; + +/** + * Base class for the game-specific main application class. + */ +class BaseGameApp +{ +public: + BaseGameApp(); + virtual ~BaseGameApp(); + + /** + * Begins application initialization in preparation for running the + * main loop. + * @param system pre-initialized operating system class + * @return TRUE if successful, FALSE if not + */ + BOOL Start(OperatingSystem *system); + + /** + * Runs the main game loop. + */ + void Loop(); + + /** + * @return operating system object + */ + OperatingSystem* GetOperatingSystem() const { return m_system; } + + /** + * @return graphics device object, or NULL if initialization failed + */ + GraphicsDevice* GetGraphicsDevice() const { return m_graphics; } + + /** + * @return keyboard input device object, or NULL if not available + */ + Keyboard* GetKeyboard() const { return m_system->GetKeyboard(); } + + /** + * @return mouse input device object, or NULL if not available + */ + Mouse* GetMouse() const { return m_system->GetMouse(); } + + /** + * @return touchscreen input device object, or NULL if not available + */ + Touchscreen* GetTouchscreen() const { return m_system->GetTouchscreen(); } + + /** + * @return content manager object, or NULL if initialization failed + */ + ContentManager* GetContentManager() const { return m_content; } + + /** + * @return the number of frames that were rendered and updated during the last second + * (this number includes skipped renders/updates in it's count) + */ + uint32_t GetFPS() const { return m_fps; } + + /** + * @return average time in seconds that each frame took during the last second + */ + float GetFrameTime() const { return m_frameTime; } + + /** + * @return total time in milliseconds that rendering took during the last second + */ + uint32_t GetRenderTime() const { return m_renderTime; } + + /** + * @return total time in milliseconds that updating game logic took during the last second + */ + uint32_t GetUpdateTime() const { return m_updateTime; } + + /** + * @return the number of frames rendered during the last second + */ + uint32_t GetRendersPerSecond() const { return m_rendersPerSecond; } + + /** + * @return the number of game logic updates during the last second + */ + uint32_t GetUpdatesPerSecond() const { return m_updatesPerSecond; } + + /** + * @return TRUE if the main loop is running behind + * (has to update game logic more then once per frame) + */ + BOOL IsRunningSlowing() const { return m_isRunningSlowly; } + + /** + * Sets the desired frames per second to run the main loop at. + * @param targetFrequency the number of frames to run the main loop at + */ + void SetUpdateFrequency(uint32_t targetFrequency); + + /** + * Sets the maximum number of frames to skip rendering per loop if the main loop is running slowly. + * @param frameSkip the maximum number of frames to skip rendering per loop + */ + void SetMaxFrameSkip(uint32_t frameSkip) { m_maxFrameSkip = frameSkip; } + + /** + * Resets the time checking that determines if the main loop is running slowly. + * The next loop will begin by assuming it is running at full speed. + */ + void ResetNextUpdateTime() { m_nextUpdateAt = GetTicks(); } + + /** + * Sets the current frame as dirty which will ensure that the next run of the loop + * will render even if a game logic update has not been run since the last render + * was performed. + */ + void Invalidate() { m_isDirty = TRUE; } + + unsigned int GetTicks() const { return m_system->GetTicks(); } + + /** + * @return TRUE if the app currently is active and has input focus + */ + BOOL IsAppFocused() const; + +protected: + /** + * Initializes the game window and the graphics and content management + * sub-systems. + * @param windowParams window creation parameters specific to the platform being run on + * @return TRUE if successful, FALSE if not + */ + BOOL Initialize(GameWindowParams *windowParams); + + /** + * Signals to the main loop that the application should quit as soon as possible. + */ + void Quit(); + +public: + /** + * Application has gained input focus callback. + */ + virtual void OnAppGainFocus() = 0; + + /** + * Application has lost input focus callback. + */ + virtual void OnAppLostFocus() = 0; + + /** + * Application execution being paused callback. + */ + virtual void OnAppPause() = 0; + + /** + * Application execution being resumed callback. + */ + virtual void OnAppResume() = 0; + + /** + * Game-specific initialization (before content loading) callback. + */ + virtual BOOL OnInit() = 0; + + /** + * Initial game load after initialization success callback. + */ + virtual void OnLoadGame() = 0; + + /** + * Lost OpenGL graphics context callback. + */ + virtual void OnLostContext(); + + /** + * New OpenGL graphics context creation callback. + */ + virtual void OnNewContext(); + + /** + * Render callback. + */ + virtual void OnRender(); + + /** + * Viewport resize callback. + */ + virtual void OnResize(); + + /** + * Update (tick) callback. + * @param delta time since last update + */ + virtual void OnUpdate(float delta); + +private: + void InternalUpdate(); + + OperatingSystem *m_system; + GameWindow *m_window; + BOOL m_stop; + BOOL m_isPaused; + + uint32_t m_fps; + float m_frameTime; + uint32_t m_numRenders; + uint32_t m_rendersPerSecond; + uint32_t m_numUpdates; + uint32_t m_updatesPerSecond; + uint32_t m_renderTime; + uint32_t m_updateTime; + + uint32_t m_targetUpdatesPerSecond; + uint32_t m_ticksPerUpdate; + uint32_t m_maxFrameSkip; + float m_fixedUpdateInterval; + uint32_t m_nextUpdateAt; + BOOL m_isRunningSlowly; + + BOOL m_isDirty; + + GraphicsDevice *m_graphics; + ContentManager *m_content; +}; + +#endif diff --git a/src/framework/common.h b/src/framework/common.h new file mode 100644 index 0000000..a519b99 --- /dev/null +++ b/src/framework/common.h @@ -0,0 +1,110 @@ +#ifndef __FRAMEWORK_COMMON_H_INCLUDED__ +#define __FRAMEWORK_COMMON_H_INCLUDED__ + +#include +#include + +#if !defined(TRUE) && !defined(FALSE) +typedef int32_t BOOL; +const BOOL TRUE = 1; +const BOOL FALSE = 0; +#endif + +#ifndef SAFE_RELEASE +#define SAFE_RELEASE(x) if (x) { (x)->Release(); (x) = NULL; } +#endif + +#ifndef SAFE_DELETE +#define SAFE_DELETE(x) if (x) { delete (x); (x) = NULL; } +#endif + +#ifndef SAFE_DELETE_ARRAY +#define SAFE_DELETE_ARRAY(x) if (x) { delete [] (x); (x) = NULL; } +#endif + +/** + * Returns the lower of two values. + * @param a the first value + * @param b the second value + * @return the lower value + */ +template +inline T Min(T a, T b) +{ + return a < b ? a : b; +} + +/** + * Returns the higher of two values. + * @param a the first value + * @param b the second value + * @return the higher value + */ +template +inline T Max(T a, T b) +{ + return a > b ? a : b; +} + +/** + * Determines if a bit is set in the given bitfield. + * @param bit the bit to check + * @param bitfield the bit field to check the bit in + * @return TRUE if set, FALSE if not + */ +template +inline BOOL IsBitSet(T1 bit, T2 bitfield) +{ + return (bitfield & bit) != 0; +} + +/** + * Sets a bit in a given bitfield. + * @param bit the bit to set + * @param bitfield the bit field to set the bit in + */ +template +inline void SetBit(T1 bit, T2 &bitfield) +{ + bitfield |= bit; +} + +/** + * Clears a bit in a given bitfield. + * @param bit the bit to clear + * @param bitfield the bit field to clear the bit in + */ +template +inline void ClearBit(T1 bit, T2 &bitfield) +{ + bitfield &= ~bit; +} + +/** + * Toggles a bit (inverts it's current state) in a given bitfield. + * @param bit the bit to toggle + * @param bitfield the bit field to toggle the bit in + */ +template +inline void ToggleBit(T1 bit, T2 &bitfield) +{ + bitfield ^= bit; +} + +/** + * Seeds the system random number generator + * @param seed the value to seed the random number generator with + */ +void SeedRnd(int32_t seed); + +/** + * Returns a random integer. + * @param low the low end of the range to generate a random integer within + * @param high the high end of the range to generate a random integer within + * @return the generated random integer + */ +int32_t Rnd(int32_t low, int32_t high); + +float Rnd(float low, float high); + +#endif \ No newline at end of file diff --git a/src/framework/content/content.cpp b/src/framework/content/content.cpp new file mode 100644 index 0000000..8439bba --- /dev/null +++ b/src/framework/content/content.cpp @@ -0,0 +1,34 @@ +#include "../debug.h" + +#include "content.h" + +Content::Content() +{ + STACK_TRACE; + m_referenceCount = 0; + m_isReferenceCounted = FALSE; + m_wasLoadedByContentLoader = FALSE; +} + +Content::~Content() +{ + STACK_TRACE; + ASSERT(m_isReferenceCounted == FALSE || m_referenceCount == 0); +} + +void Content::Reference() +{ + STACK_TRACE; + m_isReferenceCounted = TRUE; + ++m_referenceCount; +} + +void Content::ReleaseReference() +{ + STACK_TRACE; + ASSERT(m_isReferenceCounted == TRUE); + ASSERT(IsReferenced() == TRUE); + if (m_referenceCount > 0) + --m_referenceCount; +} + diff --git a/src/framework/content/content.h b/src/framework/content/content.h new file mode 100644 index 0000000..ef98af4 --- /dev/null +++ b/src/framework/content/content.h @@ -0,0 +1,119 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENT_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENT_H_INCLUDED__ + +#include "../common.h" + +class ContentLoaderBase; + +typedef const char* CONTENT_TYPE; + +/** + * Base class for content classes that are to be loaded and freed with + * ContentLoader classes and ContentManager. + */ +class Content +{ + friend class ContentLoaderBase; + +public: + Content(); + virtual ~Content(); + + /** + * @return TRUE if this content object was created by a ContentLoader + */ + BOOL WasLoadedByContentLoader() const { return m_wasLoadedByContentLoader; } + + /** + * @return TRUE if something else is currently referencing this content + */ + BOOL IsReferenced() const { return m_referenceCount > 0; } + + /** + * @return TRUE if this content is currently being reference counted + */ + BOOL IsReferenceCounted() const { return m_isReferenceCounted; } + + /** + * @return the number of references currently being held for this content + */ + uint32_t GetNumReferences() const { return m_referenceCount; } + + /** + * @return the type of content being held in this object + */ + virtual CONTENT_TYPE GetTypeOf() const = 0; + + /** + * @param the type of content to check + * @return TRUE if this content object is of type T + */ + template BOOL Is() const; + + /** + * @param type the content type to check + * @return TRUE if this content object is the same as the type specified + */ + BOOL Is(CONTENT_TYPE type) const; + + /** + * @param the type of content to attempt to cast to + * @return this content object casted to type T if this content object + * is of type T, or NULL if the types don't match + */ + template T* As(); + + /** + * @param the type of content to attempt to cast to + * @return this content object casted to type T if this content object + * is of type T, or NULL if the types don't match + */ + template const T* As() const; + +private: + /** + * Increments the reference counter by 1. + */ + void Reference(); + + /** + * Decrements the reference counter by 1. + */ + void ReleaseReference(); + + BOOL m_wasLoadedByContentLoader; + BOOL m_isReferenceCounted; + uint32_t m_referenceCount; +}; + +template +inline BOOL Content::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL Content::Is(CONTENT_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* Content::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* Content::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/framework/content/contentcontainer.h b/src/framework/content/contentcontainer.h new file mode 100644 index 0000000..8006f65 --- /dev/null +++ b/src/framework/content/contentcontainer.h @@ -0,0 +1,22 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENTCONTAINER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENTCONTAINER_H_INCLUDED__ + +#include "../common.h" + +template +struct ContentContainer +{ + T *content; + BOOL isPreLoaded; + + ContentContainer(); +}; + +template +inline ContentContainer::ContentContainer() +{ + content = NULL; + isPreLoaded = FALSE; +} + +#endif diff --git a/src/framework/content/contentloader.cpp b/src/framework/content/contentloader.cpp new file mode 100644 index 0000000..2145697 --- /dev/null +++ b/src/framework/content/contentloader.cpp @@ -0,0 +1,26 @@ +#include "../debug.h" +#include "../common.h" + +#include "contentloader.h" +#include "content.h" + +void ContentLoaderBase::MarkLoadedByContentLoader(Content *content) +{ + STACK_TRACE; + ASSERT(content != NULL); + content->m_wasLoadedByContentLoader = TRUE; +} + +void ContentLoaderBase::Reference(Content *content) +{ + STACK_TRACE; + ASSERT(content != NULL); + content->Reference(); +} + +void ContentLoaderBase::ReleaseReference(Content *content) +{ + STACK_TRACE; + ASSERT(content != NULL); + content->ReleaseReference(); +} diff --git a/src/framework/content/contentloader.h b/src/framework/content/contentloader.h new file mode 100644 index 0000000..eb30a37 --- /dev/null +++ b/src/framework/content/contentloader.h @@ -0,0 +1,146 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENTLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENTLOADER_H_INCLUDED__ + +#include "../common.h" +#include "content.h" +#include "contentparam.h" +#include + +class ContentManager; + +/** + * "Dummy" base class for ContentLoader classes. The main point of this + * class existing is so that I can _kind of_ do this: + * + * std::map*> loaders; + * + * which cannot be done as-is in C++. This "dummy" base class allows me + * to almost do the above by doing it this way instead: + * + * std::map loaders; + * + * which I like a lot better then doing it like this: + * + * std::map loaders; + */ +class ContentLoaderBase +{ +public: + ContentLoaderBase() {} + virtual ~ContentLoaderBase() {} + + /** + * Initial game load after initialization success callback. + */ + virtual void OnLoadGame() {} + + /** + * New OpenGL graphics context creation callback. + */ + virtual void OnNewContext() {} + + /** + * Lost OpenGL graphics context callback. + */ + virtual void OnLostContext() {} + + /** + * Forcefully removes all loaded content. + */ + virtual void RemoveAllContent() = 0; + + /** + * @return the type of content that this loader object is for + */ + virtual CONTENT_TYPE GetTypeOf() const = 0; + +protected: + void MarkLoadedByContentLoader(Content *content); + void Reference(Content *content); + void ReleaseReference(Content *content); +}; + +/** + * Strongly typed base class for ContentLoader classes. + * @param the type of content this class is for + */ +template +class ContentLoader : public ContentLoaderBase +{ +public: + /** + * Creates a content loader for the specified ContentManager + * @param contentManager the parent ContentManager this loader will be used with + */ + ContentLoader(ContentManager *contentManager); + + virtual ~ContentLoader(); + + /** + * Retrieves the specified content either from a cache or from the + * platform's backing storage. + * @param name the path and filename of the content to retrieve + * @param params content-type-specified parameters used during loading or NULL + * @param preload TRUE to mark the content as preloaded after loading it + * @param the type of content to load + * @return the loaded content or NULL on failure + */ + virtual T* Get(const stl::string &name, const ContentParam *params, BOOL preload = FALSE) = 0; + + /** + * Frees the specified content object. Content is only actually freed + * when it has no more references to it. + * @param content the content object to be freed + * @param preload TRUE to allow this content to be freed even if it has + * been preloaded + * @param the type of content to be freed + */ + virtual void Free(T *content, BOOL preload = FALSE) = 0; + + /** + * Frees the specified content if the content pointed to by the given path + * and filename has been loaded. Content is only actually freed when it has + * no more references to it. + * @param name the path and filename of the content to free + * @param params content-type-specific parameters that further describe the + * exact content object to be freed, or NULL + * @param preload TRUE to allow this content to be freed even if it has + * been preloaded + * @param the type of content to be freed + */ + virtual void Free(const stl::string &name, const ContentParam *params, BOOL preload = FALSE) = 0; + + /** + * Returns the path and filename that the given content object was + * loaded from. + * @param content the content object to get the path and filename for + * @param the type of content to get the path and filename for + * @return the path and filename that the content object was loaded from + */ + virtual stl::string GetNameOf(T *content) const = 0; + + /** + * @return the type of content that this loader object is for + */ + CONTENT_TYPE GetTypeOf() const { return T::GetType(); } + +protected: + ContentManager* GetContentManager() const { return m_contentManager; } + +private: + ContentManager *m_contentManager; +}; + +template +inline ContentLoader::ContentLoader(ContentManager *contentManager) +{ + m_contentManager = contentManager; +} + +template +inline ContentLoader::~ContentLoader() +{ +} + +#endif + diff --git a/src/framework/content/contentloadermapstorebase.h b/src/framework/content/contentloadermapstorebase.h new file mode 100644 index 0000000..7922610 --- /dev/null +++ b/src/framework/content/contentloadermapstorebase.h @@ -0,0 +1,256 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENTLOADERMAPSTOREBASE_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENTLOADERMAPSTOREBASE_H_INCLUDED__ + +#include "../debug.h" +#include "../common.h" +#include "../log.h" +#include "content.h" +#include "contentloader.h" +#include "contentparam.h" +#include "contentcontainer.h" +#include +#include + +class ContentManager; + +template +class ContentLoaderMapStoreBase : public ContentLoader +{ +public: + typedef stl::map > ContentStore; + typedef typename ContentStore::iterator ContentStoreItor; + typedef typename ContentStore::const_iterator ContentStoreConstItor; + + ContentLoaderMapStoreBase(const stl::string &loggingTag, ContentManager *contentManager, const stl::string &defaultPath); + virtual ~ContentLoaderMapStoreBase(); + + void SetDefaultPath(const stl::string &path); + + T* Get(const stl::string &name, const ContentParam *params, BOOL preload = FALSE); + void Free(T *content, BOOL preload = FALSE); + void Free(const stl::string &name, const ContentParam *params, BOOL preload = FALSE); + + void RemoveAllContent(); + + stl::string GetNameOf(T *content) const; + +protected: + void Free(ContentStoreItor &itor, BOOL force, BOOL preload); + + virtual ContentStoreItor FindContent(const stl::string &file, const ContentParam *params); + virtual T* LoadContent(const stl::string &file, const ContentParam *params) = 0; + virtual void FreeContent(T *content) = 0; + + stl::string AddDefaultPathIfNeeded(const stl::string &filename) const; + virtual stl::string ProcessFilename(const stl::string &filename, const ContentParam *params) const; + + const char* GetLoggingTag() const { return m_loggingTag.c_str(); } + const stl::string& GetDefaultPath() const { return m_defaultPath; } + + ContentStore m_content; + +private: + stl::string m_loggingTag; + stl::string m_defaultPath; +}; + +template +ContentLoaderMapStoreBase::ContentLoaderMapStoreBase(const stl::string &loggingTag, ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoader(contentManager) +{ + STACK_TRACE; + ASSERT(loggingTag.length() > 0); + m_loggingTag = loggingTag; + SetDefaultPath(defaultPath); +} + +template +ContentLoaderMapStoreBase::~ContentLoaderMapStoreBase() +{ + STACK_TRACE; + ASSERT(m_content.empty()); +} + +template +T* ContentLoaderMapStoreBase::Get(const stl::string &name, const ContentParam *params, BOOL preload) +{ + STACK_TRACE; + ContentContainer content; + + stl::string filename = AddDefaultPathIfNeeded(name); + filename = ProcessFilename(filename, params); + + ContentStoreItor itor = FindContent(filename, params); + if (itor != m_content.end()) + { + if (preload) + LOG_WARN(LOGCAT_ASSETS, "%s: preload specified but \"%s\" is already loaded, not precaching.\n", + GetLoggingTag(), + filename.c_str() + ); + content = itor->second; + } + else + { + T *actualContentObject = LoadContent(filename, params); + if (actualContentObject != NULL) + { + ContentLoaderBase::MarkLoadedByContentLoader(actualContentObject); + content.content = actualContentObject; + content.isPreLoaded = preload; + m_content[filename] = content; + } + } + + if (!content.isPreLoaded && content.content != NULL) + ContentLoaderBase::Reference(content.content); + + return content.content; +} + +template +void ContentLoaderMapStoreBase::Free(T *content, BOOL preload) +{ + STACK_TRACE; + ASSERT(content != NULL); + + for (ContentStoreItor itor = m_content.begin(); itor != m_content.end(); ++itor) + { + if (itor->second.content == content) + { + Free(itor, FALSE, preload); + break; + } + } +} + +template +void ContentLoaderMapStoreBase::Free(const stl::string &name, const ContentParam *params, BOOL preload) +{ + stl::string filename = AddDefaultPathIfNeeded(name); + filename = ProcessFilename(filename, params); + + ContentStoreItor itor = FindContent(filename, params); + if (itor != m_content.end()) + Free(itor, FALSE, preload); +} + +template +void ContentLoaderMapStoreBase::Free(ContentStoreItor &itor, BOOL force, BOOL preload) +{ + STACK_TRACE; + ASSERT(itor->second.content->WasLoadedByContentLoader() == TRUE); + + if (!itor->second.isPreLoaded) + ContentLoaderBase::ReleaseReference(itor->second.content); + + // don't try to free this content if it's preloaded when this method was + // not called to free preloaded content + // (however, allow it if we're forcefully freeing, of course) + if (!force && itor->second.isPreLoaded && !preload) + return; + + if (itor->second.content->IsReferenced() && force) + { + // if this is being forced, we need to manually decrease the Content's + // internal reference counter (or the destructor will have a fit). + // I suppose this is probably kind of "hack-ish"... + uint32_t numToRelease = itor->second.content->GetNumReferences(); + for (uint32_t i = 0; i < numToRelease; ++i) + ContentLoaderBase::ReleaseReference(itor->second.content); + } + + if (!itor->second.content->IsReferenced()) + { + LOG_INFO(LOGCAT_ASSETS, "%s: %sfreed %s\"%s\"\n", + GetLoggingTag(), + (force ? "forcefully " : ""), + (itor->second.isPreLoaded ? "preloaded " : ""), + itor->first.c_str() + ); + T* content = itor->second.content; + FreeContent(content); + m_content.erase(itor); + } +} + +template +void ContentLoaderMapStoreBase::RemoveAllContent() +{ + STACK_TRACE; + while (m_content.size() > 0) + { + ContentStoreItor itor = m_content.begin(); + LOG_WARN(LOGCAT_ASSETS, "%s: \"%s\" not explicitly freed (%d references%s).\n", + GetLoggingTag(), + itor->first.c_str(), + itor->second.content->GetNumReferences(), + (itor->second.isPreLoaded ? ", preloaded" : "") + ); + Free(itor, TRUE, itor->second.isPreLoaded); + } + + m_content.clear(); +} + +template +stl::string ContentLoaderMapStoreBase::GetNameOf(T *content) const +{ + STACK_TRACE; + ASSERT(content != NULL); + + for (ContentStoreConstItor itor = m_content.begin(); itor != m_content.end(); ++itor) + { + if (itor->second.content == content) + return itor->first; + } + + return ""; +} + +template +typename ContentLoaderMapStoreBase::ContentStoreItor ContentLoaderMapStoreBase::FindContent(const stl::string &file, const ContentParam *params) +{ + // default implementation, we ignore the "params" parameter completely + return m_content.find(file); +} + +template +void ContentLoaderMapStoreBase::SetDefaultPath(const stl::string &path) +{ + STACK_TRACE; + if (path.length() == 0) + { + m_defaultPath = ""; + return; + } + + m_defaultPath = path; + + if (m_defaultPath[m_defaultPath.length() - 1] != '/') + m_defaultPath += '/'; + + LOG_INFO(LOGCAT_ASSETS, "%s: default path set to \"%s\"\n", + GetLoggingTag(), + m_defaultPath.c_str() + ); +} + +template +stl::string ContentLoaderMapStoreBase::AddDefaultPathIfNeeded(const stl::string &imageFile) const +{ + STACK_TRACE; + if (imageFile[0] == '/' || m_defaultPath.length() == 0 || imageFile.substr(0, 9) == "assets://") + return imageFile; + else + return m_defaultPath + imageFile; +} + +template +stl::string ContentLoaderMapStoreBase::ProcessFilename(const stl::string &filename, const ContentParam *params) const +{ + STACK_TRACE; + return filename; +} + +#endif diff --git a/src/framework/content/contentmanager.cpp b/src/framework/content/contentmanager.cpp new file mode 100644 index 0000000..f9c18bd --- /dev/null +++ b/src/framework/content/contentmanager.cpp @@ -0,0 +1,78 @@ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "contentmanager.h" +#include "../basegameapp.h" +#include +#include + +ContentManager::ContentManager(BaseGameApp *gameApp) +{ + STACK_TRACE; + m_gameApp = gameApp; +} + +ContentManager::~ContentManager() +{ + STACK_TRACE; + for (ContentLoaderMap::iterator itor = m_loaders.begin(); itor != m_loaders.end(); ++itor) + { + ContentLoaderBase *loader = itor->second; + loader->RemoveAllContent(); + SAFE_DELETE(loader); + } +} + +void ContentManager::OnLoadGame() +{ + STACK_TRACE; + for (ContentLoaderMap::iterator itor = m_loaders.begin(); itor != m_loaders.end(); ++itor) + { + ContentLoaderBase *loader = itor->second; + loader->OnLoadGame(); + } +} + +void ContentManager::OnNewContext() +{ + STACK_TRACE; + for (ContentLoaderMap::iterator itor = m_loaders.begin(); itor != m_loaders.end(); ++itor) + { + ContentLoaderBase *loader = itor->second; + loader->OnNewContext(); + } +} + +void ContentManager::OnLostContext() +{ + STACK_TRACE; + for (ContentLoaderMap::iterator itor = m_loaders.begin(); itor != m_loaders.end(); ++itor) + { + ContentLoaderBase *loader = itor->second; + loader->OnLostContext(); + } +} + +void ContentManager::RegisterLoader(ContentLoaderBase *loader) +{ + STACK_TRACE; + ASSERT(loader != NULL); + + ContentLoaderBase *existingLoader = GetLoaderFor(loader->GetTypeOf()); + ASSERT(existingLoader == NULL); + + m_loaders[loader->GetTypeOf()] = loader; +} + +ContentLoaderBase* ContentManager::GetLoaderFor(CONTENT_TYPE type) const +{ + STACK_TRACE; + ContentLoaderMap::const_iterator itor = m_loaders.find(type); + if (itor == m_loaders.end()) + return NULL; + else + return itor->second; +} + + diff --git a/src/framework/content/contentmanager.h b/src/framework/content/contentmanager.h new file mode 100644 index 0000000..13db86d --- /dev/null +++ b/src/framework/content/contentmanager.h @@ -0,0 +1,289 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENTMANAGER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENTMANAGER_H_INCLUDED__ + +#include "../debug.h" +#include "content.h" +#include "contentparam.h" +#include "contentloader.h" +#include +#include + +class BaseGameApp; + +typedef stl::map ContentLoaderMap; + +/** + * Serves as the central point for accessing content provided by a number + * of registered content loaders for each of the individual content types. + */ +class ContentManager +{ +public: + /** + * Creates a content manager object. + * @param gameApp parent game application object + */ + ContentManager(BaseGameApp *gameApp); + + virtual ~ContentManager(); + + /** + * Initial game load after initialization success callback. + */ + void OnLoadGame(); + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + + /** + * Registers a content loader that will handle loading and freeing of + * content objects that match a specific content type. + * @param loader the pre-initialized content loader object to register + */ + void RegisterLoader(ContentLoaderBase *loader); + + /** + * Retrieves the specified content either from a cache or from the + * platform's backing storage. + * @param name the path and filename of the content to retrieve + * @param preload TRUE to mark the content as preloaded after loading it + * @param the type of content to load + * @return the loaded content or NULL on failure + */ + template T* Get(const stl::string &name, BOOL preload = FALSE); + + /** + * Retrieves the specified content either from a cache or from the + * platform's backing storage. + * @param name the path and filename of the content to retrieve + * @param params content-type-specified parameters used during loading or NULL + * @param preload TRUE to mark the content as preloaded after loading it + * @param the type of content to load + * @return the loaded content or NULL on failure + */ + template T* Get(const stl::string &name, const ContentParam ¶ms, BOOL preload = FALSE); + + /** + * Loads the content so that it is pre-loaded and subsequent calls to Get() + * for the same content are guaranteed to not require a load operation. + * Pre-loaded content is not reference counted and can only be freed with a + * call to Unload(). + * @param name the path and filename of the content to retrieve + * @param the type of content to load + * @return the loaded content or NULL on failure + */ + template T* Load(const stl::string &name); + + /** + * Loads the content so that it is pre-loaded and subsequent calls to Get() + * for the same content are guaranteed to not require a load operation. + * Pre-loaded content is not reference counted and can only be freed with a + * call to Unload(). + * @param name the path and filename of the content to retrieve + * @param params content-type-specified parameters used during loading or NULL + * @param the type of content to load + * @return the loaded content or NULL on failure + */ + template T* Load(const stl::string &name, const ContentParam ¶ms); + + /** + * Frees the specified content if the content pointed to by the given path + * and filename has been loaded. Content is only actually freed when it has + * no more references to it. + * @param name the path and filename of the content to free + * @param preload TRUE to allow this content to be freed even if it has + * been preloaded + * @param the type of content to be freed + */ + template void Free(const stl::string &name, BOOL preload = FALSE); + + /** + * Frees the specified content if the content pointed to by the given path + * and filename has been loaded. Content is only actually freed when it has + * no more references to it. + * @param name the path and filename of the content to free + * @param params content-type-specific parameters that further describe the + * exact content object to be freed, or NULL + * @param preload TRUE to allow this content to be freed even if it has + * been preloaded + * @param the type of content to be freed + */ + template void Free(const stl::string &name, const ContentParam ¶ms, BOOL preload = FALSE); + + /** + * Frees the specified content object. Content is only actually freed + * when it has no more references to it. + * @param content the content object to be freed + * @param preload TRUE to allow this content to be freed even if it has + * been preloaded + * @param the type of content to be freed + */ + template void Free(T *content, BOOL preload = FALSE); + + /** + * Frees the specified pre-loaded content. This will free the content + * immediately, even if other code is still referencing it. Pre-loaded + * content is not reference counted. + * @param name the path and filename of the content to free + * @param the type of content to be freed + */ + template void Unload(const stl::string &name); + + /** + * Frees the specified pre-loaded content. This will free the content + * immediately, even if other code is still referencing it. Pre-loaded + * content is not reference counted. + * @param name the path and filename of the content to free + * @param params content-type-specific parameters that further describe the + * exact content object to be freed, or NULL + * @param the type of content to be freed + */ + template void Unload(const stl::string &name, const ContentParam ¶ms); + + /** + * Frees the specified pre-loaded content. This will free the content + * immediately, even if other code is still referencing it. Pre-loaded + * content is not reference counted. + * @param content the content object to be freed + * @param the type of content to be freed + */ + template void Unload(T* content); + + /** + * Returns the path and filename that the given content object was + * loaded from. + * @param content the content object to get the path and filename for + * @param the type of content to get the path and filename for + * @return the path and filename that the content object was loaded from + */ + template stl::string GetNameOf(T *content) const; + + /** + * Returns the content loader object responsible for managing content of + * the specified type. + * @param the content type who's content loader object is to be returned + * @return the content loader object or NULL if none exists + */ + template ContentLoader* GetLoaderForType() const; + + /** + * @return the parent game app object + */ + BaseGameApp* GetGameApp() const { return m_gameApp; } + +private: + template ContentLoader* GetLoader() const; + ContentLoaderBase* GetLoaderFor(CONTENT_TYPE type) const; + + BaseGameApp *m_gameApp; + ContentLoaderMap m_loaders; +}; + +template +T* ContentManager::Get(const stl::string &name, BOOL preload) +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + T* content = loader->Get(name, NULL, preload); + return content; +} + +template +T* ContentManager::Get(const stl::string &name, const ContentParam ¶ms, BOOL preload) +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + T* content = loader->Get(name, ¶ms, preload); + return content; +} + +template +T* ContentManager::Load(const stl::string &name) +{ + STACK_TRACE; + return Get(name, TRUE); +} + +template +T* ContentManager::Load(const stl::string &name, const ContentParam ¶ms) +{ + STACK_TRACE; + return Get(name, params, TRUE); +} + +template +void ContentManager::Free(const stl::string &name, BOOL preload) +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + loader->Free(name, NULL, preload); +} + +template +void ContentManager::Free(const stl::string &name, const ContentParam ¶ms, BOOL preload) +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + loader->Free(name, ¶ms, preload); +} + +template +void ContentManager::Free(T *content, BOOL preload) +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + loader->Free(content, preload); +} + +template +void ContentManager::Unload(const stl::string &name) +{ + STACK_TRACE; + Free(name, TRUE); +} + +template +void ContentManager::Unload(const stl::string &name, const ContentParam ¶ms) +{ + STACK_TRACE; + Free(name, params, TRUE); +} + +template +void ContentManager::Unload(T *content) +{ + STACK_TRACE; + Free(content, TRUE); +} + +template +stl::string ContentManager::GetNameOf(T *content) const +{ + STACK_TRACE; + ContentLoader *loader = GetLoader(); + return loader->GetNameOf(content); +} + +template +ContentLoader* ContentManager::GetLoaderForType() const +{ + STACK_TRACE; + return GetLoader(); +} + +template +inline ContentLoader* ContentManager::GetLoader() const +{ + ContentLoaderBase *loaderBase = GetLoaderFor(T::GetType()); + ASSERT(loaderBase != NULL); + return (ContentLoader*)loaderBase; +} + +#endif diff --git a/src/framework/content/contentparam.h b/src/framework/content/contentparam.h new file mode 100644 index 0000000..af8369d --- /dev/null +++ b/src/framework/content/contentparam.h @@ -0,0 +1,12 @@ +#ifndef __FRAMEWORK_CONTENT_CONTENTPARAM_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_CONTENTPARAM_H_INCLUDED__ + +/** + * Base struct for content-specific parameter structures which contain + * extra information needed to load the content. + */ +struct ContentParam +{ +}; + +#endif diff --git a/src/framework/content/imageloader.cpp b/src/framework/content/imageloader.cpp new file mode 100644 index 0000000..a3886e4 --- /dev/null +++ b/src/framework/content/imageloader.cpp @@ -0,0 +1,59 @@ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "imageloader.h" + +#include "contentmanager.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../graphics/image.h" +#include "../file/file.h" +#include "../file/filesystem.h" + +#define LOGGING_TAG "ImageLoader" + +ImageLoader::ImageLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://images/") +{ + STACK_TRACE; +} + +ImageLoader::ImageLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +ImageLoader::~ImageLoader() +{ + STACK_TRACE; +} + +Image* ImageLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + File *imageFile = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(file, FILEMODE_READ | FILEMODE_BINARY); + ASSERT(imageFile != NULL); + + Image *image = new Image(); + BOOL success = image->Create(imageFile); + + SAFE_DELETE(imageFile); + + if (!success) + SAFE_DELETE(image); + + return image; +} + +void ImageLoader::FreeContent(Image *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} diff --git a/src/framework/content/imageloader.h b/src/framework/content/imageloader.h new file mode 100644 index 0000000..25bf723 --- /dev/null +++ b/src/framework/content/imageloader.h @@ -0,0 +1,40 @@ +#ifndef __FRAMEWORK_CONTENT_IMAGELOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_IMAGELOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../graphics/image.h" +#include + +class ContentManager; + +/** + * Content loader for images. + */ +class ImageLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates an image loader. + * @param contentManager the parent content manager + */ + ImageLoader(ContentManager *contentManager); + + /** + * Creates an image loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with image filenames + */ + ImageLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~ImageLoader(); + +protected: + Image* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(Image *content); +}; + +#endif + diff --git a/src/framework/content/keyframemeshloader.cpp b/src/framework/content/keyframemeshloader.cpp new file mode 100644 index 0000000..fbf0ca1 --- /dev/null +++ b/src/framework/content/keyframemeshloader.cpp @@ -0,0 +1,62 @@ +#include "../debug.h" +#include "../log.h" + +#include "keyframemeshloader.h" + +#include "contentmanager.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../assets/animation/keyframemesh.h" +#include "../assets/animation/keyframemeshfile.h" +#include "../file/file.h" +#include "../file/filesystem.h" +#include + +#define LOGGING_TAG "KeyframeMeshLoader" + +KeyframeMeshLoader::KeyframeMeshLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://meshes/") +{ + STACK_TRACE; +} + +KeyframeMeshLoader::KeyframeMeshLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +KeyframeMeshLoader::~KeyframeMeshLoader() +{ + STACK_TRACE; +} + +KeyframeMesh* KeyframeMeshLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + // load the file data + File *f = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(file, FILEMODE_READ | FILEMODE_BINARY); + KeyframeMeshFile *meshFile = new KeyframeMeshFile(f); + ASSERT(meshFile != NULL); + + // convert it into a mesh object + KeyframeMesh *mesh = new KeyframeMesh(meshFile); + SAFE_DELETE(meshFile); + + // close the file + SAFE_DELETE(f); + + return mesh; +} + +void KeyframeMeshLoader::FreeContent(KeyframeMesh *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} + diff --git a/src/framework/content/keyframemeshloader.h b/src/framework/content/keyframemeshloader.h new file mode 100644 index 0000000..8f4bb01 --- /dev/null +++ b/src/framework/content/keyframemeshloader.h @@ -0,0 +1,39 @@ +#ifndef __FRAMEWORK_CONTENT_KEYFRAMEMESHLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_KEYFRAMEMESHLOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../assets/animation/keyframemesh.h" +#include + +class ContentManager; + +/** + * Content loader for keyframe meshes. + */ +class KeyframeMeshLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates a keyframe mesh loader. + * @param contentManager the parent content manager + */ + KeyframeMeshLoader(ContentManager *contentManager); + + /** + * Creates a keyframe mesh loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with mesh filenames + */ + KeyframeMeshLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~KeyframeMeshLoader(); + +protected: + KeyframeMesh* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(KeyframeMesh *content); +}; + +#endif diff --git a/src/framework/content/skeletalmeshloader.cpp b/src/framework/content/skeletalmeshloader.cpp new file mode 100644 index 0000000..6e300f4 --- /dev/null +++ b/src/framework/content/skeletalmeshloader.cpp @@ -0,0 +1,62 @@ +#include "../debug.h" +#include "../log.h" + +#include "skeletalmeshloader.h" + +#include "contentmanager.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../assets/animation/skeletalmesh.h" +#include "../assets/animation/skeletalmeshfile.h" +#include "../file/file.h" +#include "../file/filesystem.h" +#include + +#define LOGGING_TAG "SkeletalMeshLoader" + +SkeletalMeshLoader::SkeletalMeshLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://meshes/") +{ + STACK_TRACE; +} + +SkeletalMeshLoader::SkeletalMeshLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +SkeletalMeshLoader::~SkeletalMeshLoader() +{ + STACK_TRACE; +} + +SkeletalMesh* SkeletalMeshLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + // load the file data + File *f = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(file, FILEMODE_READ | FILEMODE_BINARY); + SkeletalMeshFile *meshFile = new SkeletalMeshFile(f); + ASSERT(meshFile != NULL); + + // convert it into a mesh object + SkeletalMesh *mesh = meshFile->CreateMesh(); + SAFE_DELETE(meshFile); + + // close the file + SAFE_DELETE(f); + + return mesh; +} + +void SkeletalMeshLoader::FreeContent(SkeletalMesh *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} + diff --git a/src/framework/content/skeletalmeshloader.h b/src/framework/content/skeletalmeshloader.h new file mode 100644 index 0000000..5bee6fa --- /dev/null +++ b/src/framework/content/skeletalmeshloader.h @@ -0,0 +1,25 @@ +#ifndef __FRAMEWORK_CONTENT_SKELETALMESHLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_SKELETALMESHLOADER_H_INCLUDED__ + +#include "../common.h" + +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../assets/animation/skeletalmesh.h" +#include + +class ContentManager; + +class SkeletalMeshLoader : public ContentLoaderMapStoreBase +{ +public: + SkeletalMeshLoader(ContentManager *contentManager); + SkeletalMeshLoader(ContentManager *contentManager, const stl::string &defaultPath); + virtual ~SkeletalMeshLoader(); + +protected: + SkeletalMesh* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(SkeletalMesh *content); +}; + +#endif diff --git a/src/framework/content/spritefontloader.cpp b/src/framework/content/spritefontloader.cpp new file mode 100644 index 0000000..1164739 --- /dev/null +++ b/src/framework/content/spritefontloader.cpp @@ -0,0 +1,324 @@ +#include "../debug.h" +#include "../log.h" + +#include "spritefontloader.h" + +#include "contentmanager.h" +#include "spritefontparam.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../file/filesystem.h" +#include "../file/memoryfile.h" +#include "../graphics/color.h" +#include "../graphics/customtextureatlas.h" +#include "../graphics/graphicsdevice.h" +#include "../graphics/image.h" +#include "../graphics/spritefont.h" +#include "../graphics/texture.h" +#include "../math/rect.h" +#include "../math/rectf.h" +#include "../math/mathhelpers.h" +#include +#include +#include +#include + +#define LOGGING_TAG "SpriteFontLoader" + +SpriteFontLoader::SpriteFontLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://fonts/") +{ + STACK_TRACE; +} + +SpriteFontLoader::SpriteFontLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +SpriteFontLoader::~SpriteFontLoader() +{ + STACK_TRACE; +} + +void SpriteFontLoader::OnNewContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: reloading previous fonts for new OpenGL context.\n", GetLoggingTag()); + + for (ContentStoreItor itor = m_content.begin(); itor != m_content.end(); ++itor) + { + SpriteFont *font = itor->second.content; + if (font->GetTexture() == NULL) + { + stl::string filename; + uint8_t size = 0; + + DecomposeFilename(itor->first, filename, size); + + File *fontFile = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(filename, FILEMODE_READ | FILEMODE_BINARY); + ASSERT(fontFile != NULL); + + Load(fontFile, size, font); + + SAFE_DELETE(fontFile); + } + } +} + +void SpriteFontLoader::OnLostContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: invoking lost OpenGL context event for all loaded fonts.\n", GetLoggingTag()); + + for (ContentStoreItor itor = m_content.begin(); itor != m_content.end(); ++itor) + { + SpriteFont *font = itor->second.content; + font->OnLostContext(); + } +} + +SpriteFont* SpriteFontLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + stl::string filename; + uint8_t size = 0; + + DecomposeFilename(file, filename, size); + + File *fontFile = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(filename, FILEMODE_READ | FILEMODE_BINARY); + ASSERT(fontFile != NULL); + + SpriteFont *font = Load(fontFile, size, NULL); + + SAFE_DELETE(fontFile); + + return font; +} + +stl::string SpriteFontLoader::ProcessFilename(const stl::string &filename, const ContentParam *params) const +{ + static char buffer[1024]; + + ASSERT(filename.length() > 0); + ASSERT(params != NULL); + + const SpriteFontParam *spriteFontParams = (const SpriteFontParam*)params; + ASSERT(spriteFontParams->size > 0); + + snprintf(buffer, 1024, "%s:%d", filename.c_str(), spriteFontParams->size); + return buffer; +} + +void SpriteFontLoader::DecomposeFilename(const stl::string &filename, stl::string &outFilename, uint8_t &outSize) const +{ + STACK_TRACE; + ASSERT(filename.length() > 0); + + size_t startOfSize = filename.find_last_of(':'); + ASSERT(startOfSize != stl::string::npos); + + // break it up into filename and font size + outFilename = filename.substr(0, startOfSize); + outSize = (uint8_t)atoi(filename.substr(startOfSize + 1).c_str()); +} + +SpriteFont* SpriteFontLoader::Load(File *file, uint8_t size, SpriteFont *existing) const +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s:%d\"\n", GetLoggingTag(), file->GetFilename().c_str(), size); + + // TODO: somehow find a way to base this on the font size requested, as this + // could be really wasteful for tiny fonts + const int FONT_BITMAP_WIDTH = 1024; + const int FONT_BITMAP_HEIGHT = 1024; + const int NUM_GLYPHS = HIGH_GLYPH - LOW_GLYPH; + + uint8_t *fileData = NULL; + + if (file->GetFileType() == FILETYPE_MEMORY) + { + MemoryFile *memoryFile = (MemoryFile*)file; + fileData = (uint8_t*)memoryFile->GetFileData(); + } + else + { + size_t fileSize = file->GetFileSize(); + fileData = new uint8_t[fileSize]; + file->Read((int8_t*)fileData, fileSize); + } + + stbtt_fontinfo fontinfo; + int initResult = stbtt_InitFont(&fontinfo, fileData, 0); + if (!initResult) + return NULL; + + // get glyph metrics for the "maximum size" glyph as an indicator of the + // general size of each glyph in this font. Uppercase 'W' seems to be a + // pretty good glyph to represent this "maximum size". + SpriteFontGlyphMetrics maxMetrics; + BOOL maxMetricResult = GetGlyphMetrics(&fontinfo, 'W', size, &maxMetrics); + ASSERT(maxMetricResult == TRUE); + + // if we can't even get this glyph's metrics then stop now + if (!maxMetricResult) + return NULL; + + // the raw bitmap that we will be building. using a fixed size which should hopefully be good enough for the limited charset + // that we're allowing as long as the font pixel size doesn't get too large + // this bitmap is *only* going to contain alpha values (not any kind of rgb colour data) + Image *bitmap = new Image(); + BOOL bitmapCreateSuccess = bitmap->Create(FONT_BITMAP_WIDTH, FONT_BITMAP_HEIGHT, IMAGE_FORMAT_ALPHA); + ASSERT(bitmapCreateSuccess == TRUE); + bitmap->Clear(); + + // the texture atlas to store the position/texcoords of each glyph + CustomTextureAtlas *glyphs = new CustomTextureAtlas(bitmap->GetWidth(), bitmap->GetHeight()); + ASSERT(glyphs != NULL); + + // NOTE TO SELF: a lot of this feels "hackish" and that some weird font isn't going to play nice with this. clean this up at some point! + + // current position to draw the glyph to on the bitmap + int x = 0; + int y = 0; + + // total line height for each row of glyphs on the bitmap. this is not really the font height. + // it is likely slightly larger then that. this adds the font's descent a second time to make + // vertical room for a few of the glyphs (e.g. '{}' or '()', or even '$') which go off the + // top/bottom by a slight bit + int lineHeight = (maxMetrics.ascent - maxMetrics.descent) + maxMetrics.lineGap - maxMetrics.descent; + + for (int i = 0; i < NUM_GLYPHS; ++i) + { + // get metrics for the current glyph + char c = (char)(i + LOW_GLYPH); + SpriteFontGlyphMetrics glyphMetrics; + BOOL metricResult = GetGlyphMetrics(&fontinfo, c, size, &glyphMetrics); + ASSERT(metricResult == TRUE); + + // adjust each glyph's rect so that it has it's own space that doesn't + // collide with any of it's neighbour glyphs (neighbour as seen on the + // font bitmap) + if (glyphMetrics.dimensions.left < 0) + { + // bump the glyph over to the right by the same amount it was over to the left + glyphMetrics.advance += -glyphMetrics.dimensions.left; + glyphMetrics.dimensions.left = 0; + } + + // do we need to move to the next row? + if ((x + glyphMetrics.advance + glyphMetrics.dimensions.left) >= bitmap->GetWidth()) + { + // yes + x = 0; + y += lineHeight; + ASSERT((y + lineHeight) < bitmap->GetHeight()); + } + + // the destination bitmap pixel coordinates of this glyph. these are the + // pixel coordinates that will be stored in the font's texture atlas + // which will be used by the texture atlas to build texture coords + Rect position( + x, + y, + x + glyphMetrics.advance, + y + lineHeight + ); + + // top-left coords and dimensions to have stb_truetype draw the glyph at in the font bitmap + int drawX = position.left + glyphMetrics.dimensions.left; + int drawY = (position.bottom + glyphMetrics.descent) + glyphMetrics.descent - glyphMetrics.dimensions.bottom + maxMetrics.lineGap; + int drawWidth = position.GetWidth(); + int drawHeight = position.GetHeight(); + + // use stb_truetype to render the glyph onto the bitmap + int pixelsDestOffset = drawX + (drawY * bitmap->GetWidth()); + stbtt_MakeGlyphBitmap(&fontinfo, bitmap->GetPixels() + pixelsDestOffset, drawWidth, drawHeight, bitmap->GetWidth(), maxMetrics.scale, maxMetrics.scale, glyphMetrics.index); + + // add the glyph position to the texture atlas (which will calc the texture coords for us) + int newIndex = glyphs->Add(position); + ASSERT(newIndex == ((int)c - LOW_GLYPH)); + + // move to the next glyph's position in the bitmap + x += maxMetrics.advance; + } + + Texture *fontTexture = new Texture(); + BOOL textureCreated = fontTexture->Create(GetContentManager()->GetGameApp()->GetGraphicsDevice(), bitmap); + ASSERT(textureCreated == TRUE); + SAFE_DELETE(bitmap); + if (!textureCreated) + { + // clean up + SAFE_DELETE(fontTexture); + SAFE_DELETE(glyphs); + if (file->GetFileType() != FILETYPE_MEMORY) + SAFE_DELETE_ARRAY(fileData); + return NULL; + } + + if (file->GetFileType() != FILETYPE_MEMORY) + SAFE_DELETE_ARRAY(fileData); + + // re-loading an existing font object instance, or creating a new one? + SpriteFont *result; + if (existing != NULL) + result = existing; + else + { + result = new SpriteFont(); + ASSERT(result != NULL); + } + result->Load(fontTexture, glyphs, size); + return result; +} + +void SpriteFontLoader::FreeContent(SpriteFont *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} + +BOOL SpriteFontLoader::GetGlyphMetrics(stbtt_fontinfo *fontInfo, char glyph, uint8_t size, SpriteFontGlyphMetrics *metrics) const +{ + STACK_TRACE; + ASSERT(metrics != NULL); + + // need to properly scale! sizes as returned from most (all?) metric-related functions will be huge + // (I will at this point admit that I don't fully understand what units the metric functions are working with + // and why this scale value is necessary... I just haven't read enough into this stuff I guess) + metrics->scale = stbtt_ScaleForPixelHeight(fontInfo, (float)size); + + metrics->letterHeight = size; + + metrics->index = stbtt_FindGlyphIndex(fontInfo, glyph); + if (metrics->index == 0) + return FALSE; + + stbtt_GetGlyphBox(fontInfo, metrics->index, &metrics->dimensions.left, &metrics->dimensions.top, &metrics->dimensions.right, &metrics->dimensions.bottom); + stbtt_GetFontVMetrics(fontInfo, &metrics->ascent, &metrics->descent, &metrics->lineGap); + stbtt_GetGlyphHMetrics(fontInfo, metrics->index, &metrics->advance, NULL); + + // adjust all the metrics we got by the font size scale value + // (I guess this puts them from whatever units they were in to pixel units) + metrics->dimensions.left = (int)ceil(metrics->dimensions.left * metrics->scale); + metrics->dimensions.top = (int)ceil(metrics->dimensions.top * metrics->scale); + metrics->dimensions.right = (int)ceil(metrics->dimensions.right * metrics->scale); + metrics->dimensions.bottom = (int)ceil(metrics->dimensions.bottom * metrics->scale); + metrics->ascent = (int)ceil(metrics->ascent * metrics->scale); + metrics->descent = (int)ceil(metrics->descent * metrics->scale); + metrics->lineGap = (int)ceil(metrics->lineGap * metrics->scale); + metrics->advance = (int)ceil(metrics->advance * metrics->scale); + metrics->letterWidth = metrics->dimensions.right - metrics->dimensions.left; + + // seen some pixel/bitmap fonts that have the total ascent/descent calculated height + // greater then the pixel height. this just figures out this difference, if present, + // and sets an appropriate line gap equal to it (in these cases, linegap was 0) + int calculatedHeight = metrics->ascent - metrics->descent; + int heightDifference = abs(calculatedHeight - metrics->letterHeight); + if (heightDifference != metrics->lineGap && metrics->lineGap == 0) + metrics->lineGap = heightDifference; + + return TRUE; +} diff --git a/src/framework/content/spritefontloader.h b/src/framework/content/spritefontloader.h new file mode 100644 index 0000000..4706fc8 --- /dev/null +++ b/src/framework/content/spritefontloader.h @@ -0,0 +1,86 @@ +#ifndef __FRAMEWORK_CONTENT_SPRITEFONTLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_SPRITEFONTLOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../graphics/spritefont.h" +#include "../math/rect.h" +#include +#include + +class ContentManager; +class File; + +struct SpriteFontGlyphMetrics +{ + int index; + float scale; + Rect dimensions; + int ascent; + int descent; + int lineGap; + int advance; + int letterWidth; + int letterHeight; + + SpriteFontGlyphMetrics() + { + index = 0; + scale = 0.0f; + dimensions = Rect(0, 0, 0, 0); + ascent = 0; + descent = 0; + lineGap = 0; + advance = 0; + letterWidth = 0; + letterHeight = 0; + } +}; + +/** + * Content loader for sprite fonts. + */ +class SpriteFontLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates a sprite font loader. + * @param contentManager the parent content manager + */ + SpriteFontLoader(ContentManager *contentManager); + + /** + * Creates a sprite font loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with font filenames + */ + SpriteFontLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~SpriteFontLoader(); + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + +protected: + stl::string ProcessFilename(const stl::string &filename, const ContentParam *params) const; + + SpriteFont* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(SpriteFont *content); + +private: + void DecomposeFilename(const stl::string &filename, stl::string &outFilename, uint8_t &outSize) const; + SpriteFont* Load(File *file, uint8_t size, SpriteFont *existing) const; + + BOOL GetGlyphMetrics(stbtt_fontinfo *fontInfo, char glyph, uint8_t size, SpriteFontGlyphMetrics *glyphMetrics) const; +}; + +#endif diff --git a/src/framework/content/spritefontparam.h b/src/framework/content/spritefontparam.h new file mode 100644 index 0000000..1200d58 --- /dev/null +++ b/src/framework/content/spritefontparam.h @@ -0,0 +1,17 @@ +#ifndef __FRAMEWORK_CONTENT_SPRITEFONTPARAM_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_SPRITEFONTPARAM_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" + +struct SpriteFontParam : public ContentParam +{ + uint8_t size; + + SpriteFontParam(uint8_t size) + { + this->size = size; + } +}; + +#endif diff --git a/src/framework/content/staticmeshloader.cpp b/src/framework/content/staticmeshloader.cpp new file mode 100644 index 0000000..0e49562 --- /dev/null +++ b/src/framework/content/staticmeshloader.cpp @@ -0,0 +1,62 @@ +#include "../debug.h" +#include "../log.h" + +#include "staticmeshloader.h" + +#include "contentmanager.h" +#include "textureloader.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../file/file.h" +#include "../file/filesystem.h" +#include "../assets/static/staticmesh.h" +#include "../assets/static/staticmeshfile.h" +#include + +const char* LOGGING_TAG = "StaticMeshLoader"; + +StaticMeshLoader::StaticMeshLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://meshes/") +{ + STACK_TRACE; +} + +StaticMeshLoader::StaticMeshLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +StaticMeshLoader::~StaticMeshLoader() +{ + STACK_TRACE; +} + +StaticMesh* StaticMeshLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + // load the file data + File *f = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(file, FILEMODE_READ | FILEMODE_BINARY); + StaticMeshFile *meshFile = new StaticMeshFile(f); + ASSERT(meshFile != NULL); + + // convert it into a mesh object + StaticMesh *mesh = new StaticMesh(meshFile, GetContentManager()); + SAFE_DELETE(meshFile); + + // done with the file now + SAFE_DELETE(f); + + return mesh; +} + +void StaticMeshLoader::FreeContent(StaticMesh *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} diff --git a/src/framework/content/staticmeshloader.h b/src/framework/content/staticmeshloader.h new file mode 100644 index 0000000..63e22df --- /dev/null +++ b/src/framework/content/staticmeshloader.h @@ -0,0 +1,39 @@ +#ifndef __FRAMEWORK_CONTENT_STATICMESHLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_STATICMESHLOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../assets/static/staticmesh.h" +#include + +class ContentManager; + +/** + * Content loader for static meshes. + */ +class StaticMeshLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates a static mesh loader. + * @param contentManager the parent content manager + */ + StaticMeshLoader(ContentManager *contentManager); + + /** + * Creates a static mesh loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with mesh filenames + */ + StaticMeshLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~StaticMeshLoader(); + +protected: + StaticMesh* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(StaticMesh *content); +}; + +#endif diff --git a/src/framework/content/textloader.cpp b/src/framework/content/textloader.cpp new file mode 100644 index 0000000..08f3321 --- /dev/null +++ b/src/framework/content/textloader.cpp @@ -0,0 +1,57 @@ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "textloader.h" + +#include "contentmanager.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../support/text.h" +#include "../file/file.h" +#include "../file/filesystem.h" +#include + +#define LOGGING_TAG "TextLoader" + +TextLoader::TextLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "") +{ + STACK_TRACE; +} + +TextLoader::TextLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +TextLoader::~TextLoader() +{ + STACK_TRACE; +} + +Text* TextLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + File *textFile = GetContentManager()->GetGameApp()->GetOperatingSystem()->GetFileSystem()->Open(file, FILEMODE_READ); + ASSERT(textFile != NULL); + + Text *text = Text::CreateFrom(textFile); + ASSERT(text != NULL); + + SAFE_DELETE(textFile); + + return text; +} + +void TextLoader::FreeContent(Text *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} diff --git a/src/framework/content/textloader.h b/src/framework/content/textloader.h new file mode 100644 index 0000000..002e6f9 --- /dev/null +++ b/src/framework/content/textloader.h @@ -0,0 +1,40 @@ +#ifndef __FRAMEWORK_CONTENT_TEXTLOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_TEXTLOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../support/text.h" +#include + +class ContentManager; + +/** + * Content loader for text files. + */ +class TextLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates a text file loader. + * @param contentManager the parent content manager + */ + TextLoader(ContentManager *contentManager); + + /** + * Creates a text file loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with text filenames + */ + TextLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~TextLoader(); + +protected: + Text* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(Text *content); +}; + +#endif + diff --git a/src/framework/content/textureloader.cpp b/src/framework/content/textureloader.cpp new file mode 100644 index 0000000..f6b0afe --- /dev/null +++ b/src/framework/content/textureloader.cpp @@ -0,0 +1,109 @@ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "textureloader.h" + +#include "contentmanager.h" +#include "imageloader.h" +#include "../basegameapp.h" +#include "../operatingsystem.h" +#include "../graphics/graphicsdevice.h" +#include "../graphics/image.h" +#include "../graphics/texture.h" +#include "../file/file.h" +#include "../file/filesystem.h" +#include + +#define LOGGING_TAG "TextureLoader" + +TextureLoader::TextureLoader(ContentManager *contentManager) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, "assets://textures/") +{ + STACK_TRACE; +} + +TextureLoader::TextureLoader(ContentManager *contentManager, const stl::string &defaultPath) + : ContentLoaderMapStoreBase(LOGGING_TAG, contentManager, defaultPath) +{ + STACK_TRACE; +} + +TextureLoader::~TextureLoader() +{ + STACK_TRACE; +} + +void TextureLoader::OnNewContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: reloading previous textures for new OpenGL context.\n", GetLoggingTag()); + + for (ContentStoreItor itor = m_content.begin(); itor != m_content.end(); ++itor) + { + Texture *reloaded = Load(itor->first, itor->second.content); + if (reloaded == NULL) + { + LOG_WARN(LOGCAT_ASSETS, "%s: failed reloading texture \"%s\"\n", + GetLoggingTag(), + itor->first.c_str() + ); + } + } +} + +void TextureLoader::OnLostContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: resetting loaded texture IDs due to lost OpenGL context.\n", GetLoggingTag()); + + for (ContentStoreItor itor = m_content.begin(); itor != m_content.end(); ++itor) + itor->second.content->OnLostContext(); +} + +Texture* TextureLoader::LoadContent(const stl::string &file, const ContentParam *params) +{ + STACK_TRACE; + return Load(file, NULL); +} + +void TextureLoader::FreeContent(Texture *content) +{ + STACK_TRACE; + SAFE_DELETE(content); +} + +Texture* TextureLoader::Load(const stl::string &file, Texture *existingTexture) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "%s: loading \"%s\"\n", + GetLoggingTag(), + file.c_str() + ); + + Image *image = GetContentManager()->Get(file.c_str()); + ASSERT(image != NULL); + if (image == NULL) + return NULL; + + // use existing texture object given, or create a new one + Texture *texture = existingTexture; + if (texture == NULL) + texture = new Texture(); + + // load image into it + BOOL success = texture->Create(GetContentManager()->GetGameApp()->GetGraphicsDevice(), image); + + // don't need to keep the underlying image around if not being used elsewhere + GetContentManager()->Free(image); + + // if texture creation fails and we allocated the texture object ourselves, + // we should free it ourselves. existing texture objects are the caller's + // responsibility of course + if (!success && existingTexture != NULL) + { + SAFE_DELETE(texture); + } + + return texture; +} diff --git a/src/framework/content/textureloader.h b/src/framework/content/textureloader.h new file mode 100644 index 0000000..329941b --- /dev/null +++ b/src/framework/content/textureloader.h @@ -0,0 +1,52 @@ +#ifndef __FRAMEWORK_CONTENT_TEXTURELOADER_H_INCLUDED__ +#define __FRAMEWORK_CONTENT_TEXTURELOADER_H_INCLUDED__ + +#include "../common.h" +#include "contentparam.h" +#include "contentloadermapstorebase.h" +#include "../graphics/texture.h" +#include + +class ContentManager; + +/** + * Content loader for textures. + */ +class TextureLoader : public ContentLoaderMapStoreBase +{ +public: + /** + * Creates a texture loader. + * @param contentManager the parent content manager + */ + TextureLoader(ContentManager *contentManager); + + /** + * Creates a texture loader. + * @param contentManager the parent content manager + * @param defaultPath the default path to use if, when loading, paths aren't + * provided with texture filenames + */ + TextureLoader(ContentManager *contentManager, const stl::string &defaultPath); + + virtual ~TextureLoader(); + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + +protected: + Texture* LoadContent(const stl::string &file, const ContentParam *params); + void FreeContent(Texture *content); + +private: + Texture* Load(const stl::string &file, Texture *existingTexture = NULL); +}; + +#endif diff --git a/src/framework/debug.cpp b/src/framework/debug.cpp new file mode 100644 index 0000000..4bf6603 --- /dev/null +++ b/src/framework/debug.cpp @@ -0,0 +1,154 @@ +#include "debug.h" + +#include +#include +#include +#include +#include + +#include "log.h" +#include "util/msgbox.h" + +const int32_t STACK_ENTRY_STACK_SIZE = 32; +const int32_t STACK_ENTRY_BUFFER_SIZE = 512; +const int32_t STACK_TRACE_BUFFER_SIZE = 2048; +const int32_t DEBUG_ASSERT_BUFFER_SIZE = 2048; + +void DebugInit() +{ +#if defined(_WIN32) && defined(_DEBUG) && defined(DEBUG_MEM_LEAK_CHECK) + int tmpFlags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); + tmpFlags |= _CRTDBG_CHECK_ALWAYS_DF; + tmpFlags |= _CRTDBG_DELAY_FREE_MEM_DF; + tmpFlags |= _CRTDBG_LEAK_CHECK_DF; + _CrtSetDbgFlag(tmpFlags); +#endif + +#ifdef DEBUG + LOG_DEBUG(LOGCAT_DEBUG, "DEBUG enabled for this build.\n"); +#endif +} + +void DebugClose() +{ +} + +int DebugAssert(const char *expression, const char *file, unsigned long line, const char *function, int *ignore) +{ + char buffer[DEBUG_ASSERT_BUFFER_SIZE]; + int ret = 0; + +#ifdef DEBUG_STACK_TRACE + snprintf(buffer, DEBUG_ASSERT_BUFFER_SIZE, + "ASSERT FAILED\n\n" + "EXPRESSION: %s\n" + "FILE: %s\n" + "LINE: %ld\n" + "FUNCTION: %s\n\n" + "STACK TRACE:\n%s\n", + expression, file, line, function, DebugStackTrace()); +#else + snprintf(buffer, DEBUG_ASSERT_BUFFER_SIZE, + "ASSERT FAILED\n\n" + "EXPRESSION: %s\n" + "FILE: %s\n" + "LINE: %ld\n" + "FUNCTION: %s\n", + expression, file, line, function); +#endif + + LOG_ERROR(LOGCAT_DEBUG, buffer); + MSGBOX_RESULT result = MsgBox_AbortRetryIgnore(MSGBOX_TYPE_WARNING, buffer, "Assert Failed"); + switch (result) + { + case MSGBOX_RESULT_ABORT: + ret = 1; + break; + case MSGBOX_RESULT_IGNORE: + *ignore = 1; + ret = 0; + break; + case MSGBOX_RESULT_RETRY: + ret = 0; + break; + default: + ret = 0; + } + +#ifdef DESKTOP + fflush(NULL); +#endif + return ret; +} + +const char* DebugStackTrace() +{ +#ifdef DEBUG_STACK_TRACE + return StackTrace::Instance().GetTrace(); +#endif + return ""; +} + +StackTrace::StackTrace() +{ + m_traceBuffer = new char[STACK_TRACE_BUFFER_SIZE]; + m_entryStack = new char*[STACK_ENTRY_STACK_SIZE]; + for (int i = 0; i < STACK_ENTRY_STACK_SIZE; ++i) + m_entryStack[i] = new char[STACK_ENTRY_BUFFER_SIZE]; + m_entryStackPointer = 0; + Clear(); +} + +StackTrace::~StackTrace() +{ + delete[] m_traceBuffer; + for (int i = 0; i < STACK_ENTRY_STACK_SIZE; ++i) + delete[] m_entryStack[i]; + delete[] m_entryStack; + Clear(); +} + +StackTrace& StackTrace::Instance() +{ + static StackTrace stackTrace; + return stackTrace; +} + +void StackTrace::Push(char *entry) +{ + assert(m_entryStackPointer < STACK_ENTRY_STACK_SIZE); + snprintf(m_entryStack[m_entryStackPointer], STACK_ENTRY_BUFFER_SIZE, "%s", entry); + ++m_entryStackPointer; +} + +void StackTrace::Pop() +{ + --m_entryStackPointer; + m_entryStack[m_entryStackPointer][0] = '\0'; +} + +void StackTrace::Clear() +{ + m_entryStackPointer = 0; +} + +char* StackTrace::GetTrace() +{ + *m_traceBuffer = '\0'; + for (int pointer = m_entryStackPointer; pointer >= 0; --pointer) + snprintf(m_traceBuffer, STACK_TRACE_BUFFER_SIZE, "%s%s\n", m_traceBuffer, m_entryStack[pointer]); + + return m_traceBuffer; +} + +StackEntry::StackEntry(const char *file, unsigned long line, const char *function) +{ + static char buffer[STACK_ENTRY_BUFFER_SIZE]; + snprintf(buffer, STACK_ENTRY_BUFFER_SIZE, "%s:%ld:%s", file, line, function); + StackTrace::Instance().Push(buffer); +} + +StackEntry::~StackEntry() +{ + StackTrace::Instance().Pop(); +} diff --git a/src/framework/debug.h b/src/framework/debug.h new file mode 100644 index 0000000..8e348e0 --- /dev/null +++ b/src/framework/debug.h @@ -0,0 +1,180 @@ +#ifndef __FRAMEWORK_DEBUG_H_INCLUDED__ +#define __FRAMEWORK_DEBUG_H_INCLUDED__ + +#if defined(_WIN32) && defined(_DEBUG) && defined(DEBUG_MEM_LEAK_CHECK) +#define _CRTDBG_MAP_ALLOC +#include +#include +#define DEBUG_CLIENTBLOCK new(_CLIENT_BLOCK, __FILE__, __LINE__) +#define new DEBUG_CLIENTBLOCK +#else +#define DEBUG_CLIENTBLOCK +#endif + +#include + +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#define WIN32_EXTRA_LEAN +#include +#endif + +#ifdef DEBUG_STACK_TRACE + /** + * Call stack tracing macro. Simply include this at the top of + * any function to be tracked in the stack history. + */ + #ifdef __GNUC__ + #define STACK_TRACE StackEntry __stackEntry(__FILE__, __LINE__, __PRETTY_FUNCTION__) + #else + #define STACK_TRACE StackEntry __stackEntry(__FILE__, __LINE__, __FUNCSIG__) + #endif +#else + #define STACK_TRACE +#endif + +#ifdef DEBUG + /** + * Toggles a breakpoint in an attached debugger. + */ + #ifdef __GNUC__ + // Debug ARM builds using Marmalade SDK don't seem to like inline asm... + #if (defined(__S3E__) && defined(__arm__) && defined(DEBUG)) + #define BREAKPOINT + #elif (defined(__arm__) || defined(__thumb__)) + #define BREAKPOINT __asm__ ("bkpt 0") + #else + #define BREAKPOINT __asm__ ("int $3") + #endif + #elif _MSC_VER + #define BREAKPOINT __asm int 0x3 + #else + #error Unsupported compiler + #endif +#else + #define BREAKPOINT +#endif + +#ifdef DEBUG + #ifdef __GNUC__ + #define ASSERT(exp) \ + do { \ + static int ignore = 0; \ + if (!ignore && !(exp)) \ + { \ + if (DebugAssert(#exp, __FILE__, __LINE__, __PRETTY_FUNCTION__, &ignore)) \ + BREAKPOINT; \ + } \ + } while(0) + #elif _MSC_VER + #define ASSERT(exp) \ + do { \ + static int ignore = 0; \ + if (!ignore && !(exp)) \ + { \ + if (DebugAssert(#exp, __FILE__, __LINE__, __FUNCSIG__, &ignore)) \ + BREAKPOINT \ + } \ + } while(0) + #else + #error Unsupported compiler + #endif +#else + #define ASSERT(exp) assert((exp)) +#endif + +#define _STATIC_ASSERT_TEST_(a, b) a ## b +#define _STATIC_ASSERT_TEST(a, b) _STATIC_ASSERT_TEST_(a, b) + +/** + * Compile-time assertions. Essentially a watered-down variant of + * BOOST_STATIC_ASSERT and C++11's static_assert() + */ +#define STATIC_ASSERT(exp) typedef int _STATIC_ASSERT_TEST(static_assert_test_var_, __LINE__)[(exp) ? 1 : -1] + +/** + * Maintains a list of call stack entries. Entries need to be + * manually pushed/popped off this list. + * + * This class should not be used directly. Instead use the STACK_TRACE + * macro and DebugStackTrace() function. + */ +class StackTrace +{ +public: + static StackTrace& Instance(); + + StackTrace(); + ~StackTrace(); + + /** + * Add new entry onto the top of call stack history. + * @param entry the entry to add + */ + void Push(char *entry); + + /** + * Remove top entry off the call stack history. + */ + void Pop(); + + /** + * Remove all entries from the call stack history. + */ + void Clear(); + + int GetSize() { return m_entryStackPointer + 1; } + + /** + * @return formatted string containing the call stack + * entries top-to-bottom + */ + char* GetTrace(); + +private: + char *m_traceBuffer; + char **m_entryStack; + int m_entryStackPointer; +}; + +/** + * Used by the STACK_TRACE macro to push/pop entries onto the + * actual stack. + * + * This class should not be used directly. + */ +class StackEntry +{ +public: + StackEntry(const char *file, unsigned long line, const char *function); + ~StackEntry(); +}; + +/** + * Initializes the debug framework. + */ +void DebugInit(); + +/* + * Closes up the debug framework. + */ +void DebugClose(); + +/** + * Logs assert information for failed assertions. + * @param expression expression/condition that failed + * @param file source file of expression + * @param line source line in file of expression + * @param function function name where assertion failed + * @param ignore returns whether the user selected to ignore + * future asserts or not + */ +int DebugAssert(const char *expression, const char *file, unsigned long line, const char *function, int *ignore); + +/** + * Gets the current call stack as recorded by the STACK_TRACE macros. + * @return formatted string containing the call stack + */ +const char* DebugStackTrace(); + +#endif diff --git a/src/framework/file/diskfile.cpp b/src/framework/file/diskfile.cpp new file mode 100644 index 0000000..7c56c98 --- /dev/null +++ b/src/framework/file/diskfile.cpp @@ -0,0 +1,350 @@ +#include "../debug.h" +#include "../log.h" + +#include "diskfile.h" + +DiskFile::DiskFile() + : File() +{ + STACK_TRACE; + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; +} + +DiskFile::~DiskFile() +{ + STACK_TRACE; + Close(); +} + +BOOL DiskFile::Open(const stl::string &filename, int mode) +{ + STACK_TRACE; + ASSERT(IsOpen() == FALSE); + m_filename = filename; + + char fopenMode[3] = { '\0', '\0', '\0' }; + if (mode & FILEMODE_READ) + { + fopenMode[0] = 'r'; + m_canRead = TRUE; + } + else if (mode & FILEMODE_WRITE) + { + fopenMode[0] = 'w'; + m_canWrite = TRUE; + } + else if (mode & FILEMODE_APPEND) + { + fopenMode[0] = 'a'; + m_canWrite = TRUE; + } + if (mode & FILEMODE_BINARY && fopenMode[0] != '\0') + fopenMode[1] = 'b'; + + if (fopenMode[0] == '\0') + { + ASSERT(!"Unrecognized mode."); + return FALSE; + } + else + { + ASSERT(m_canRead == TRUE || m_canWrite == TRUE); + + m_fp = fopen(filename.c_str(), fopenMode); + if (m_fp) + { + LOG_INFO(LOGCAT_FILEIO, "Opened DiskFile \"%s\", mode = %s\n", filename.c_str(), fopenMode); + m_mode = mode; + return TRUE; + } + else + { + LOG_WARN(LOGCAT_FILEIO, "Failed to open DiskFile \"%s\", mode = %s\n", filename.c_str(), fopenMode); + return FALSE; + } + } +} + +void DiskFile::Close() +{ + STACK_TRACE; + if (IsOpen()) + { + LOG_INFO(LOGCAT_FILEIO, "Closed DiskFile \"%s\"\n", m_filename.c_str()); + fclose(m_fp); + } + + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; + m_filename.clear(); +} + +int8_t DiskFile::ReadChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int8_t buffer; + fread(&buffer, sizeof(int8_t), 1, m_fp); + return buffer; +} + +uint8_t DiskFile::ReadUnsignedChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint8_t buffer; + fread(&buffer, sizeof(uint8_t), 1, m_fp); + return buffer; +} + +int16_t DiskFile::ReadShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int16_t buffer; + fread(&buffer, sizeof(int16_t), 1, m_fp); + return buffer; +} + +uint16_t DiskFile::ReadUnsignedShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint16_t buffer; + fread(&buffer, sizeof(uint16_t), 1, m_fp); + return buffer; +} + +int32_t DiskFile::ReadInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int32_t buffer; + fread(&buffer, sizeof(int32_t), 1, m_fp); + return buffer; +} + +uint32_t DiskFile::ReadUnsignedInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint32_t buffer; + fread(&buffer, sizeof(uint32_t), 1, m_fp); + return buffer; +} + +int64_t DiskFile::ReadLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int64_t buffer; + fread(&buffer, sizeof(int64_t), 1, m_fp); + return buffer; +} + +uint64_t DiskFile::ReadUnsignedLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint64_t buffer; + fread(&buffer, sizeof(uint64_t), 1, m_fp); + return buffer; +} + +float DiskFile::ReadFloat() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + float buffer; + fread(&buffer, sizeof(float), 1, m_fp); + return buffer; +} + +double DiskFile::ReadDouble() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + double buffer; + fread(&buffer, sizeof(double), 1, m_fp); + return buffer; +} + +size_t DiskFile::Read(int8_t *buffer, size_t bytesToRead) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + ASSERT(buffer != NULL); + ASSERT(bytesToRead > 0); + size_t numRead = fread(buffer, bytesToRead, 1, m_fp); + return (numRead * bytesToRead); +} + +size_t DiskFile::ReadString(stl::string &buffer) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + do + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + } while (c != '\0'); + + return charactersRead; +} + +size_t DiskFile::ReadFixedString(stl::string &buffer, size_t maxLength) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + for (size_t i = 0; i < maxLength; ++i) + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + if (c == '\0') + break; + } + + return charactersRead; +} + +size_t DiskFile::WriteChar(int8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(int8_t), 1, m_fp); + return (numWritten * sizeof(int8_t)); +} + +size_t DiskFile::WriteUnsignedChar(uint8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(uint8_t), 1, m_fp); + return (numWritten * sizeof(uint8_t)); +} + +size_t DiskFile::WriteShort(int16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(int16_t), 1, m_fp); + return (numWritten * sizeof(int16_t)); +} + +size_t DiskFile::WriteUnsignedShort(uint16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(uint16_t), 1, m_fp); + return (numWritten * sizeof(uint16_t)); +} + +size_t DiskFile::WriteInt(int32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(int32_t), 1, m_fp); + return (numWritten * sizeof(int32_t)); +} + +size_t DiskFile::WriteUnsignedInt(uint32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(uint32_t), 1, m_fp); + return (numWritten * sizeof(uint32_t)); +} + +size_t DiskFile::WriteLong(int64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(int64_t), 1, m_fp); + return (numWritten * sizeof(int64_t)); +} + +size_t DiskFile::WriteUnsignedLong(uint64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(uint64_t), 1, m_fp); + return (numWritten * sizeof(uint64_t)); +} + +size_t DiskFile::WriteFloat(float data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(float), 1, m_fp); + return (numWritten * sizeof(float)); +} + +size_t DiskFile::WriteDouble(double data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = fwrite(&data, sizeof(double), 1, m_fp); + return (numWritten * sizeof(double)); +} + +size_t DiskFile::Write(int8_t *buffer, size_t bytesToWrite) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + ASSERT(buffer != NULL); + ASSERT(bytesToWrite > 0); + size_t numWritten = fwrite(buffer, bytesToWrite, 1, m_fp); + return (numWritten * bytesToWrite); +} + +size_t DiskFile::Tell() +{ + ASSERT(IsOpen()); + return (size_t)ftell(m_fp); +} + +void DiskFile::Seek(size_t offset, FileSeek from) +{ + ASSERT(IsOpen()); + + int origin = SEEK_CUR; + if (from == FILESEEK_BEGINNING) + origin = SEEK_SET; + else if (from == FILESEEK_END) + origin = SEEK_END; + + fseek(m_fp, offset, origin); +} + +BOOL DiskFile::AtEOF() +{ + ASSERT(IsOpen()); + return feof(m_fp) != 0; +} + +size_t DiskFile::GetFileSize() +{ + ASSERT(IsOpen()); + size_t currentPos = Tell(); + Seek(0, FILESEEK_END); + size_t filesize = Tell(); + Seek(currentPos, FILESEEK_BEGINNING); + return filesize; +} \ No newline at end of file diff --git a/src/framework/file/diskfile.h b/src/framework/file/diskfile.h new file mode 100644 index 0000000..cbdd216 --- /dev/null +++ b/src/framework/file/diskfile.h @@ -0,0 +1,69 @@ +#ifndef __FRAMEWORK_FILE_DISKFILE_H_INCLUDED__ +#define __FRAMEWORK_FILE_DISKFILE_H_INCLUDED__ + +#include "../common.h" +#include "file.h" + +#include +#include + +/** + * Generic file class using only the C Standard Library for file + * I/O operations. + */ +class DiskFile : public File +{ +public: + DiskFile(); + virtual ~DiskFile(); + + BOOL Open(const stl::string &filename, int mode); + void Close(); + + BOOL IsOpen() const { return m_fp != NULL; } + BOOL CanRead() const { return m_canRead; } + BOOL CanWrite() const { return m_canWrite; } + FileType GetFileType() const { return FILETYPE_IO; } + + int8_t ReadChar(); + uint8_t ReadUnsignedChar(); + int16_t ReadShort(); + uint16_t ReadUnsignedShort(); + int32_t ReadInt(); + uint32_t ReadUnsignedInt(); + int64_t ReadLong(); + uint64_t ReadUnsignedLong(); + float ReadFloat(); + double ReadDouble(); + size_t Read(int8_t *buffer, size_t bytesToRead); + size_t ReadString(stl::string &buffer); + size_t ReadFixedString(stl::string &buffer, size_t maxLength); + + size_t WriteChar(int8_t data); + size_t WriteUnsignedChar(uint8_t data); + size_t WriteShort(int16_t data); + size_t WriteUnsignedShort(uint16_t data); + size_t WriteInt(int32_t data); + size_t WriteUnsignedInt(uint32_t data); + size_t WriteLong(int64_t data); + size_t WriteUnsignedLong(uint64_t data); + size_t WriteFloat(float data); + size_t WriteDouble(double data); + size_t Write(int8_t *buffer, size_t bytesToWrite); + + size_t Tell(); + void Seek(size_t offset, FileSeek from); + BOOL AtEOF(); + size_t GetFileSize(); + + const stl::string& GetFilename() const { return m_filename; } + +private: + FILE *m_fp; + int m_mode; + BOOL m_canRead; + BOOL m_canWrite; + stl::string m_filename; +}; + +#endif diff --git a/src/framework/file/file.h b/src/framework/file/file.h new file mode 100644 index 0000000..017a8c6 --- /dev/null +++ b/src/framework/file/file.h @@ -0,0 +1,268 @@ +#ifndef __FRAMEWORK_FILE_FILE_H_INCLUDED__ +#define __FRAMEWORK_FILE_FILE_H_INCLUDED__ + +#include +#include "../common.h" + +enum FileMode +{ + FILEMODE_READ = 1, + FILEMODE_WRITE = 2, + FILEMODE_BINARY = 4, + FILEMODE_APPEND = 8, + FILEMODE_MEMORY = 16 +}; + +enum FileSeek +{ + FILESEEK_BEGINNING, + FILESEEK_CURRENT, + FILESEEK_END +}; + +enum FileType +{ + FILETYPE_IO, + FILETYPE_MEMORY +}; + +/** + * Represents a file that can be read from and/or written to. + */ +class File +{ +public: + File() {} + virtual ~File() {} + + /** + * Closes the file. + */ + virtual void Close() = 0; + + /** + * @return TRUE if the file is currently open + */ + virtual BOOL IsOpen() const = 0; + + /** + * @return TRUE if this file supports reading + */ + virtual BOOL CanRead() const = 0; + + /** + * @return TRUE if this file supports writing + */ + virtual BOOL CanWrite() const = 0; + + /** + * @return a type value representing the backing storage where this file's + * data is located + */ + virtual FileType GetFileType() const = 0; + + /** + * Reads and returns the next signed 8-bit value from the file and then + * advances the current file pointer. + * @return the signed 8-bit value read from the file + */ + virtual int8_t ReadChar() = 0; + + /** + * Reads and returns the next unsigned 8-bit value from the file and then + * advances the current file pointer. + * @return the unsigned 8-bit value read from the file + */ + virtual uint8_t ReadUnsignedChar() = 0; + + /** + * Reads and returns the next signed 16-bit value from the file and then + * advances the current file pointer. + * @return the signed 16-bit value read from the file + */ + virtual int16_t ReadShort() = 0; + + /** + * Reads and returns the next unsigned 16-bit value from the file and then + * advances the current file pointer. + * @return the unsigned 16-bit value read from the file + */ + virtual uint16_t ReadUnsignedShort() = 0; + + /** + * Reads and returns the next signed 32-bit value from the file and then + * advances the current file pointer. + * @return the signed 32-bit value read from the file + */ + virtual int32_t ReadInt() = 0; + + /** + * Reads and returns the next unsigned 32-bit value from the file and then + * advances the current file pointer. + * @return the unsigned 32-bit value read from the file + */ + virtual uint32_t ReadUnsignedInt() = 0; + + /** + * Reads and returns the next signed 64-bit value from the file and then + * advances the current file pointer. + * @return the signed 64-bit value read from the file + */ + virtual int64_t ReadLong() = 0; + + /** + * Reads and returns the next unsigned 64-bit value from the file and then + * advances the current file pointer. + * @return the unsigned 64-bit value read from the file + */ + virtual uint64_t ReadUnsignedLong() = 0; + + /** + * Reads and returns the next 32-bit floating point value from the file + * and then advances the current file pointer. + * @return the 32-bit floating point value read from the file + */ + virtual float ReadFloat() = 0; + + /** + * Reads and returns the next 64-bit floating point value from the file + * and then advances the current file pointer. + * @return the 64-bit floating point value read from the file + */ + virtual double ReadDouble() = 0; + + /** + * Reads the specified number of bytes and stores it in the provided buffer. + * @param buffer the pre-allocated buffer to store the read data in + * @param bytesToRead the number of bytes to read + * @return the number of bytes read + */ + virtual size_t Read(int8_t *buffer, size_t bytesToRead) = 0; + + /** + * Reads a null-terminated string from the file. Reading stops at the first + * NULL character encountered. + * @param buffer the string to store the read characters in + * @return the number of characters read, not including the NULL terminator + */ + virtual size_t ReadString(stl::string &buffer) = 0; + + /** + * Reads a null-terminated string from the file. Reading stops when either + * the maximum length specified has been reached or the first NULL character + * is encountered. + * @param buffer the string to store the read characters in + * @param maxLength the maximum number of characters to read + * @return the number of characters read, not including the NULL terminator + */ + virtual size_t ReadFixedString(stl::string &buffer, size_t maxLength) = 0; + + /** + * Writes a signed 8-bit value to the file. + * @param data the signed 8-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteChar(int8_t data) = 0; + + /** + * Writes an unsigned 8-bit value to the file. + * @param data the unsigned 8-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteUnsignedChar(uint8_t data) = 0; + + /** + * Writes a signed 16-bit value to the file. + * @param data the signed 16-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteShort(int16_t data) = 0; + + /** + * Writes an unsigned 16-bit value to the file. + * @param data the unsigned 16-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteUnsignedShort(uint16_t data) = 0; + + /** + * Writes a signed 32-bit value to the file. + * @param data the signed 32-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteInt(int32_t data) = 0; + + /** + * Writes an unsigned 32-bit value to the file. + * @param data the unsigned 32-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteUnsignedInt(uint32_t data) = 0; + + /** + * Writes a signed 64-bit value to the file. + * @param data the signed 64-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteLong(int64_t data) = 0; + + /** + * Writes an unsigned 64-bit value to the file. + * @param data the unsigned 64-bit value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteUnsignedLong(uint64_t data) = 0; + + /** + * Writes a 32-bit floating point value to the file. + * @param data the 32-bit floating point value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteFloat(float data) = 0; + + /** + * Writes a 64-bit floating point value to the file. + * @param data the 64-bit floating point value to write + * @return the number of bytes written to the file + */ + virtual size_t WriteDouble(double data) = 0; + + /** + * Writes a buffer of data to the file. + * @param buffer the buffer of data to write + * @param bytesToWrite the number of bytes from the buffer to write + * @return the number of bytes written to the file + */ + virtual size_t Write(int8_t *buffer, size_t bytesToWrite) = 0; + + /** + * @return the current file pointer position as an offset number of bytes + * from the beginning of the file + */ + virtual size_t Tell() = 0; + + /** + * Moves the current file pointer by a given amount from the position + * specified. + * @param offset the number of bytes to move + * @param from the position to move relative to + */ + virtual void Seek(size_t offset, FileSeek from) = 0; + + /** + * @return TRUE if the current file pointer is at the end of the file + */ + virtual BOOL AtEOF() = 0; + + /** + * @return the size of this file in bytes + */ + virtual size_t GetFileSize() = 0; + + /** + * @return the path and filename of this file + */ + virtual const stl::string& GetFilename() const = 0; +}; + +#endif diff --git a/src/framework/file/filesystem.h b/src/framework/file/filesystem.h new file mode 100644 index 0000000..7bba549 --- /dev/null +++ b/src/framework/file/filesystem.h @@ -0,0 +1,43 @@ +#ifndef __FRAMEWORK_FILE_FILESYSTEM_H_INCLUDED__ +#define __FRAMEWORK_FILE_FILESYSTEM_H_INCLUDED__ + +#include + +class File; + +/** + * Represents the current platform's filesystem, provided methods + * for opening files and for translating paths using the "assets://" + * and "storage://" prefixes to their equivalent locations understood + * by the underlying operating system. + */ +class FileSystem +{ +public: + FileSystem() {} + virtual ~FileSystem() {} + + /** + * Opens a file. + * @param filename the path and filename of the file to open + * @param mode the mode to open the file in + * @return a file object for the opened file, or NULL if not successful + */ + virtual File* Open(const stl::string &filename, int mode) = 0; + + /** + * Translates a path and filename which may include a "assets://" or + * "storage://" prefix to the full path understood by the underlying + * platform / operating system. + * @param filename path and filename to translate + * @return the translated path + */ + virtual stl::string TranslateFilePath(const stl::string &filename) const = 0; + + /** + * @return the path to the root of the assets directory + */ + virtual const stl::string& GetAssetsPath() const = 0; +}; + +#endif diff --git a/src/framework/file/marmaladefile.cpp b/src/framework/file/marmaladefile.cpp new file mode 100644 index 0000000..57e62b8 --- /dev/null +++ b/src/framework/file/marmaladefile.cpp @@ -0,0 +1,381 @@ +#ifdef __S3E__ +#include "../debug.h" +#include "../log.h" + +#include "marmaladefile.h" +#include "s3eFile.h" + +MarmaladeFile::MarmaladeFile() + : File() +{ + STACK_TRACE; + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; +} + +MarmaladeFile::~MarmaladeFile() +{ + STACK_TRACE; + Close(); +} + +BOOL MarmaladeFile::Open(const stl::string &filename, int mode) +{ + STACK_TRACE; + ASSERT(IsOpen() == FALSE); + m_filename = filename; + + char fopenMode[3] = { '\0', '\0', '\0' }; + if (mode & FILEMODE_READ) + { + fopenMode[0] = 'r'; + m_canRead = TRUE; + } + else if (mode & FILEMODE_WRITE) + { + fopenMode[0] = 'w'; + m_canWrite = TRUE; + } + else if (mode & FILEMODE_APPEND) + { + fopenMode[0] = 'a'; + m_canWrite = TRUE; + } + if (mode & FILEMODE_BINARY && fopenMode[0] != '\0') + fopenMode[1] = 'b'; + + if (fopenMode[0] == '\0') + { + ASSERT(!"Unrecognized mode."); + return FALSE; + } + else + { + ASSERT(m_canRead == TRUE || m_canWrite == TRUE); + + m_fp = s3eFileOpen(filename.c_str(), fopenMode); + if (m_fp) + { + LOG_INFO(LOGCAT_FILEIO, "Opened MarmaladeFile \"%s\", mode = %s\n", filename.c_str(), fopenMode); + m_mode = mode; + return TRUE; + } + else + { + LOG_WARN(LOGCAT_FILEIO, "Failed to open MarmaladeFile \"%s\", mode = %s. Error: %d, %s\n", filename.c_str(), fopenMode, s3eFileGetError(), s3eFileGetErrorString()); + return FALSE; + } + } +} + +void MarmaladeFile::Close() +{ + STACK_TRACE; + if (IsOpen()) + { + LOG_INFO(LOGCAT_FILEIO, "Closed MarmaladeFile \"%s\"\n", m_filename.c_str()); + s3eFileClose(m_fp); + } + + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; + m_filename.clear(); +} + +int8_t MarmaladeFile::ReadChar() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + int8_t buffer; + s3eFileRead(&buffer, sizeof(int8_t), 1, m_fp); + return buffer; +} + +uint8_t MarmaladeFile::ReadUnsignedChar() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint8_t buffer; + s3eFileRead(&buffer, sizeof(uint8_t), 1, m_fp); + return buffer; +} + +int16_t MarmaladeFile::ReadShort() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + int16_t buffer; + s3eFileRead(&buffer, sizeof(int16_t), 1, m_fp); + return buffer; +} + +uint16_t MarmaladeFile::ReadUnsignedShort() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint16_t buffer; + s3eFileRead(&buffer, sizeof(uint16_t), 1, m_fp); + return buffer; +} + +int32_t MarmaladeFile::ReadInt() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + int32_t buffer; + s3eFileRead(&buffer, sizeof(int32_t), 1, m_fp); + return buffer; +} + +uint32_t MarmaladeFile::ReadUnsignedInt() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint32_t buffer; + s3eFileRead(&buffer, sizeof(uint32_t), 1, m_fp); + return buffer; +} + +int64_t MarmaladeFile::ReadLong() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + int64_t buffer; + s3eFileRead(&buffer, sizeof(int64_t), 1, m_fp); + return buffer; +} + +uint64_t MarmaladeFile::ReadUnsignedLong() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint64_t buffer; + s3eFileRead(&buffer, sizeof(uint64_t), 1, m_fp); + return buffer; +} + +float MarmaladeFile::ReadFloat() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + float buffer; + s3eFileRead(&buffer, sizeof(float), 1, m_fp); + return buffer; +} + +double MarmaladeFile::ReadDouble() +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + double buffer; + s3eFileRead(&buffer, sizeof(double), 1, m_fp); + return buffer; +} + +size_t MarmaladeFile::Read(int8_t *buffer, size_t bytesToRead) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + ASSERT(buffer != NULL); + ASSERT(bytesToRead > 0); + size_t numRead = s3eFileRead(buffer, bytesToRead, 1, m_fp); + return (numRead * bytesToRead); +} + +size_t MarmaladeFile::ReadString(stl::string &buffer) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + do + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + } while (c != '\0'); + + return charactersRead; +} + +size_t MarmaladeFile::ReadFixedString(stl::string &buffer, size_t maxLength) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + for (size_t i = 0; i < maxLength; ++i) + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + if (c == '\0') + break; + } + + return charactersRead; +} + +size_t MarmaladeFile::WriteChar(int8_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(int8_t), 1, m_fp); + return (numWritten * sizeof(int8_t)); +} + +size_t MarmaladeFile::WriteUnsignedChar(uint8_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(uint8_t), 1, m_fp); + return (numWritten * sizeof(uint8_t)); +} + +size_t MarmaladeFile::WriteShort(int16_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(int16_t), 1, m_fp); + return (numWritten * sizeof(int16_t)); +} + +size_t MarmaladeFile::WriteUnsignedShort(uint16_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(uint16_t), 1, m_fp); + return (numWritten * sizeof(uint16_t)); +} + +size_t MarmaladeFile::WriteInt(int32_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(int32_t), 1, m_fp); + return (numWritten * sizeof(int32_t)); +} + +size_t MarmaladeFile::WriteUnsignedInt(uint32_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(uint32_t), 1, m_fp); + return (numWritten * sizeof(uint32_t)); +} + +size_t MarmaladeFile::WriteLong(int64_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(int64_t), 1, m_fp); + return (numWritten * sizeof(int64_t)); +} + +size_t MarmaladeFile::WriteUnsignedLong(uint64_t data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(uint64_t), 1, m_fp); + return (numWritten * sizeof(uint64_t)); +} + +size_t MarmaladeFile::WriteFloat(float data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(float), 1, m_fp); + return (numWritten * sizeof(float)); +} + +size_t MarmaladeFile::WriteDouble(double data) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = s3eFileWrite(&data, sizeof(double), 1, m_fp); + return (numWritten * sizeof(double)); +} + +size_t MarmaladeFile::Write(int8_t *buffer, size_t bytesToWrite) +{ + STACK_TRACE; + ASSERT(IsOpen()); + ASSERT(CanWrite()); + ASSERT(buffer != NULL); + ASSERT(bytesToWrite > 0); + size_t numWritten = s3eFileWrite(buffer, bytesToWrite, 1, m_fp); + return (numWritten * bytesToWrite); +} + +size_t MarmaladeFile::Tell() +{ + STACK_TRACE; + ASSERT(IsOpen()); + return (size_t)s3eFileTell(m_fp); +} + +void MarmaladeFile::Seek(size_t offset, FileSeek from) +{ + STACK_TRACE; + ASSERT(IsOpen()); + + s3eFileSeekOrigin origin = S3E_FILESEEK_CUR; + if (from == FILESEEK_BEGINNING) + origin = S3E_FILESEEK_SET; + else if (from == FILESEEK_END) + origin = S3E_FILESEEK_END; + + s3eFileSeek(m_fp, offset, origin); +} + +BOOL MarmaladeFile::AtEOF() +{ + STACK_TRACE; + ASSERT(IsOpen()); + if (s3eFileEOF(m_fp) == S3E_TRUE) + return TRUE; + else + return FALSE; +} + +size_t MarmaladeFile::GetFileSize() +{ + STACK_TRACE; + ASSERT(IsOpen()); + return (size_t)s3eFileGetSize(m_fp); +} + +#endif diff --git a/src/framework/file/marmaladefile.h b/src/framework/file/marmaladefile.h new file mode 100644 index 0000000..9ad8bea --- /dev/null +++ b/src/framework/file/marmaladefile.h @@ -0,0 +1,66 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_FILE_MARMALADEFILE_H_INCLUDED__ +#define __FRAMEWORK_FILE_MARMALADEFILE_H_INCLUDED__ + +#include "../common.h" + +#include "file.h" +#include "s3eFile.h" + +class MarmaladeFile : public File +{ +public: + MarmaladeFile(); + virtual ~MarmaladeFile(); + + BOOL Open(const stl::string &filename, int mode); + void Close(); + + BOOL IsOpen() const { return m_fp != NULL; } + BOOL CanRead() const { return m_canRead; } + BOOL CanWrite() const { return m_canWrite; } + FileType GetFileType() const { return FILETYPE_IO; } + + int8_t ReadChar(); + uint8_t ReadUnsignedChar(); + int16_t ReadShort(); + uint16_t ReadUnsignedShort(); + int32_t ReadInt(); + uint32_t ReadUnsignedInt(); + int64_t ReadLong(); + uint64_t ReadUnsignedLong(); + float ReadFloat(); + double ReadDouble(); + size_t Read(int8_t *buffer, size_t bytesToRead); + size_t ReadString(stl::string &buffer); + size_t ReadFixedString(stl::string &buffer, size_t maxLength); + + size_t WriteChar(int8_t data); + size_t WriteUnsignedChar(uint8_t data); + size_t WriteShort(int16_t data); + size_t WriteUnsignedShort(uint16_t data); + size_t WriteInt(int32_t data); + size_t WriteUnsignedInt(uint32_t data); + size_t WriteLong(int64_t data); + size_t WriteUnsignedLong(uint64_t data); + size_t WriteFloat(float data); + size_t WriteDouble(double data); + size_t Write(int8_t *buffer, size_t bytesToWrite); + + size_t Tell(); + void Seek(size_t offset, FileSeek from); + BOOL AtEOF(); + size_t GetFileSize(); + + const stl::string& GetFilename() const { return m_filename; } + +private: + s3eFile *m_fp; + int m_mode; + BOOL m_canRead; + BOOL m_canWrite; + stl::string m_filename; +}; + +#endif +#endif diff --git a/src/framework/file/marmaladefilesystem.cpp b/src/framework/file/marmaladefilesystem.cpp new file mode 100644 index 0000000..aeae3cd --- /dev/null +++ b/src/framework/file/marmaladefilesystem.cpp @@ -0,0 +1,88 @@ +#ifdef __S3E__ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "marmaladefilesystem.h" + +#include "file.h" +#include "filesystem.h" +#include "marmaladefile.h" +#include "memoryfile.h" +#include "util.h" + +MarmaladeFileSystem::MarmaladeFileSystem() + : FileSystem() +{ + STACK_TRACE; + m_assetsPath = ::GetAssetsPath(); + LOG_INFO(LOGCAT_FILEIO, "FileSystem assets path is \"%s\".\n", m_assetsPath.c_str()); +} + +MarmaladeFileSystem::~MarmaladeFileSystem() +{ + STACK_TRACE; +} + +File* MarmaladeFileSystem::Open(const stl::string &filename, int mode) +{ + STACK_TRACE; + File *result = NULL; + stl::string realFilename = TranslateFilePath(filename); + + if (mode & FILEMODE_MEMORY) + result = OpenMemory(realFilename, mode); + else + result = OpenFile(realFilename, mode); + + return result; +} + +File* MarmaladeFileSystem::OpenFile(const stl::string &filename, int mode) +{ + STACK_TRACE; + MarmaladeFile *file = new MarmaladeFile(); + ASSERT(file != NULL); + + if (file->Open(filename, mode)) + return file; + else + { + SAFE_DELETE(file); + return NULL; + } +} + +File* MarmaladeFileSystem::OpenMemory(const stl::string &filename, int mode) +{ + STACK_TRACE; + // open the specified file off the disk (or whatever) + File *file = OpenFile(filename, mode); + if (file == NULL) + return NULL; + + // read the entire file contents into memory + MemoryFile *memoryFile = new MemoryFile(); + ASSERT(memoryFile != NULL); + if (!memoryFile->Open(file)) + { + SAFE_DELETE(memoryFile); // sets NULL, so this returns NULL on failure + } + + // close the source file, we're done with it either way + file->Close(); + SAFE_DELETE(file); + + return memoryFile; +} + +stl::string MarmaladeFileSystem::TranslateFilePath(const stl::string &filename) const +{ + STACK_TRACE; + if (filename.substr(0, 9) == "assets://") + return m_assetsPath + filename.substr(9); + else + return filename; +} + +#endif diff --git a/src/framework/file/marmaladefilesystem.h b/src/framework/file/marmaladefilesystem.h new file mode 100644 index 0000000..6647b92 --- /dev/null +++ b/src/framework/file/marmaladefilesystem.h @@ -0,0 +1,30 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_FILE_MARMALADEFILESYSTEM_H_INCLUDED__ +#define __FRAMEWORK_FILE_MARMALADEFILESYSTEM_H_INCLUDED__ + +#include + +#include "filesystem.h" + +class File; + +class MarmaladeFileSystem : public FileSystem +{ +public: + MarmaladeFileSystem(); + virtual ~MarmaladeFileSystem(); + + File* Open(const stl::string &filename, int mode); + + stl::string TranslateFilePath(const stl::string &filename) const; + const stl::string& GetAssetsPath() const { return m_assetsPath; } + +private: + File* OpenFile(const stl::string &filename, int mode); + File* OpenMemory(const stl::string &filename, int mode); + + stl::string m_assetsPath; +}; + +#endif +#endif diff --git a/src/framework/file/memoryfile.cpp b/src/framework/file/memoryfile.cpp new file mode 100644 index 0000000..6265e88 --- /dev/null +++ b/src/framework/file/memoryfile.cpp @@ -0,0 +1,371 @@ +#include "../debug.h" +#include "../log.h" + +#include "memoryfile.h" + +#include + +MemoryFile::MemoryFile() + : File() +{ + STACK_TRACE; + m_data = NULL; + m_ownData = FALSE; + m_length = 0; + m_position = 0; + m_canRead = FALSE; + m_canWrite = FALSE; +} + +MemoryFile::~MemoryFile() +{ + STACK_TRACE; + Close(); +} + +BOOL MemoryFile::Open(File *srcFile) +{ + STACK_TRACE; + ASSERT(IsOpen() == FALSE); + ASSERT(srcFile->IsOpen()); + size_t filesize = srcFile->GetFileSize(); + m_data = new int8_t[filesize]; + ASSERT(m_data != NULL); + m_ownData = TRUE; + m_length = filesize; + m_filename = srcFile->GetFilename(); + + m_canRead = srcFile->CanRead(); + m_canWrite = srcFile->CanWrite(); + + srcFile->Read(m_data, filesize); + + LOG_INFO(LOGCAT_FILEIO, "Create MemoryFile from source file \"%s\"\n", srcFile->GetFilename().c_str()); + + return TRUE; +} + +BOOL MemoryFile::Open(const void *memory, size_t numBytes, BOOL canRead, BOOL canWrite, BOOL assumeOwnershipOfMemory) +{ + STACK_TRACE; + ASSERT(IsOpen() == FALSE); + ASSERT(memory != NULL); + ASSERT(numBytes > 0); + ASSERT(canRead == TRUE || canWrite == TRUE); + + m_data = (int8_t*)memory; + m_ownData = assumeOwnershipOfMemory; + m_length = numBytes; + m_filename.clear(); + + m_canRead = canRead; + m_canWrite = canWrite; + + return TRUE; +} + +void MemoryFile::Close() +{ + STACK_TRACE; + if (IsOpen()) + { + if (m_ownData) + SAFE_DELETE_ARRAY(m_data); + + if (m_filename.size() > 0) + LOG_INFO(LOGCAT_FILEIO, "Free MemoryFile \"%s\"\n", m_filename.c_str()); + } + + m_ownData = FALSE; + m_length = 0; + m_position = 0; + m_canRead = FALSE; + m_canWrite = FALSE; + m_filename.clear(); +} + +int8_t MemoryFile::ReadChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(int8_t); + return *(int8_t*)p; +} + +uint8_t MemoryFile::ReadUnsignedChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(uint8_t); + return *(uint8_t*)p; +} + +int16_t MemoryFile::ReadShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(int16_t); + return *(int16_t*)p; +} + +uint16_t MemoryFile::ReadUnsignedShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(uint16_t); + return *(uint16_t*)p; +} + +int32_t MemoryFile::ReadInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(int32_t); + return *(int32_t*)p; +} + +uint32_t MemoryFile::ReadUnsignedInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(uint32_t); + return *(uint32_t*)p; +} + +int64_t MemoryFile::ReadLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(int64_t); + return *(int64_t*)p; +} + +uint64_t MemoryFile::ReadUnsignedLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(uint64_t); + return *(uint64_t*)p; +} + +float MemoryFile::ReadFloat() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(float); + return *(float*)p; +} + +double MemoryFile::ReadDouble() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + void *p = &m_data[m_position]; + m_position += sizeof(double); + return *(double*)p; +} + +size_t MemoryFile::Read(int8_t *buffer, size_t bytesToRead) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + ASSERT(buffer != NULL); + ASSERT(bytesToRead > 0); + size_t actualBytesToRead = Min(bytesToRead, m_length - m_position); + void *p = &m_data[m_position]; + memcpy(buffer, p, actualBytesToRead); + m_position += actualBytesToRead; + return actualBytesToRead; +} + +size_t MemoryFile::ReadString(stl::string &buffer) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + do + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + } while (c != '\0'); + + return charactersRead; +} + + +size_t MemoryFile::ReadFixedString(stl::string &buffer, size_t maxLength) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + for (size_t i = 0; i < maxLength; ++i) + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + if (c == '\0') + break; + } + + return charactersRead; +} + +size_t MemoryFile::WriteChar(int8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + int8_t *p = (int8_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(int8_t); + return sizeof(int8_t); +} + +size_t MemoryFile::WriteUnsignedChar(uint8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + uint8_t *p = (uint8_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(uint8_t); + return sizeof(uint8_t); +} + +size_t MemoryFile::WriteShort(int16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + int16_t *p = (int16_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(int16_t); + return sizeof(int16_t); +} + +size_t MemoryFile::WriteUnsignedShort(uint16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + uint16_t *p = (uint16_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(uint16_t); + return sizeof(uint16_t); +} + +size_t MemoryFile::WriteInt(int32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + int32_t *p = (int32_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(int32_t); + return sizeof(int32_t); +} + +size_t MemoryFile::WriteUnsignedInt(uint32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + uint32_t *p = (uint32_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(uint32_t); + return sizeof(uint32_t); +} + +size_t MemoryFile::WriteLong(int64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + int64_t *p = (int64_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(int64_t); + return sizeof(int64_t); +} + +size_t MemoryFile::WriteUnsignedLong(uint64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + uint64_t *p = (uint64_t*)&m_data[m_position]; + *p = data; + m_position += sizeof(uint64_t); + return sizeof(uint64_t); +} + +size_t MemoryFile::WriteFloat(float data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + float *p = (float*)&m_data[m_position]; + *p = data; + m_position += sizeof(float); + return sizeof(float); +} + +size_t MemoryFile::WriteDouble(double data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + double *p = (double*)&m_data[m_position]; + *p = data; + m_position += sizeof(double); + return sizeof(double); +} + +size_t MemoryFile::Write(int8_t *buffer, size_t bytesToWrite) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + ASSERT(buffer != NULL); + ASSERT(bytesToWrite > 0); + size_t actualBytesToWrite = Min(bytesToWrite, m_length - m_position); + void *p = &m_data[m_position]; + memcpy(p, buffer, actualBytesToWrite); + m_position += actualBytesToWrite; + return actualBytesToWrite; +} + +size_t MemoryFile::Tell() +{ + ASSERT(IsOpen()); + return m_position; +} + +void MemoryFile::Seek(size_t offset, FileSeek from) +{ + ASSERT(IsOpen()); + if (from == FILESEEK_BEGINNING) + m_position = offset; + else if (from == FILESEEK_END) + m_position = m_length - offset; + else + m_position += offset; +} + +BOOL MemoryFile::AtEOF() +{ + ASSERT(IsOpen()); + return m_position >= m_length; +} + +size_t MemoryFile::GetFileSize() +{ + ASSERT(IsOpen()); + return m_length; +} diff --git a/src/framework/file/memoryfile.h b/src/framework/file/memoryfile.h new file mode 100644 index 0000000..40d16b0 --- /dev/null +++ b/src/framework/file/memoryfile.h @@ -0,0 +1,71 @@ +#ifndef __FRAMEWORK_FILE_MEMORYFILE_H_INCLUDED__ +#define __FRAMEWORK_FILE_MEMORYFILE_H_INCLUDED__ + +#include "../common.h" +#include "file.h" + +/** + * File class that uses a block of memory as it's backing storage for + * I/O operations. + */ +class MemoryFile : public File +{ +public: + MemoryFile(); + virtual ~MemoryFile(); + + BOOL Open(File *srcFile); + BOOL Open(const void *memory, size_t numBytes, BOOL canRead, BOOL canWrite, BOOL assumeOwnershipOfMemory = FALSE); + void Close(); + + BOOL IsOpen() const { return m_data != NULL; } + BOOL CanRead() const { return m_canRead; } + BOOL CanWrite() const { return m_canWrite; } + FileType GetFileType() const { return FILETYPE_MEMORY; } + + int8_t ReadChar(); + uint8_t ReadUnsignedChar(); + int16_t ReadShort(); + uint16_t ReadUnsignedShort(); + int32_t ReadInt(); + uint32_t ReadUnsignedInt(); + int64_t ReadLong(); + uint64_t ReadUnsignedLong(); + float ReadFloat(); + double ReadDouble(); + size_t Read(int8_t *buffer, size_t bytesToRead); + size_t ReadString(stl::string &buffer); + size_t ReadFixedString(stl::string &buffer, size_t maxLength); + + size_t WriteChar(int8_t data); + size_t WriteUnsignedChar(uint8_t data); + size_t WriteShort(int16_t data); + size_t WriteUnsignedShort(uint16_t data); + size_t WriteInt(int32_t data); + size_t WriteUnsignedInt(uint32_t data); + size_t WriteLong(int64_t data); + size_t WriteUnsignedLong(uint64_t data); + size_t WriteFloat(float data); + size_t WriteDouble(double data); + size_t Write(int8_t *buffer, size_t bytesToWrite); + + size_t Tell(); + void Seek(size_t offset, FileSeek from); + BOOL AtEOF(); + size_t GetFileSize(); + + const stl::string& GetFilename() const { return m_filename; } + + int8_t* GetFileData() const { return m_data; } + +private: + int8_t *m_data; + BOOL m_ownData; + size_t m_length; + size_t m_position; + BOOL m_canRead; + BOOL m_canWrite; + stl::string m_filename; +}; + +#endif diff --git a/src/framework/file/sdlfile.cpp b/src/framework/file/sdlfile.cpp new file mode 100644 index 0000000..e0a0c0d --- /dev/null +++ b/src/framework/file/sdlfile.cpp @@ -0,0 +1,357 @@ +#ifdef SDL +#include "../debug.h" +#include "../log.h" + +#include "sdlfile.h" + +SDLFile::SDLFile() + : File() +{ + STACK_TRACE; + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; +} + +SDLFile::~SDLFile() +{ + STACK_TRACE; + Close(); +} + +BOOL SDLFile::Open(const stl::string &filename, int mode) +{ + STACK_TRACE; + ASSERT(IsOpen() == FALSE); + m_filename = filename; + + char fopenMode[3] = { '\0', '\0', '\0' }; + if (mode & FILEMODE_READ) + { + fopenMode[0] = 'r'; + m_canRead = TRUE; + } + else if (mode & FILEMODE_WRITE) + { + fopenMode[0] = 'w'; + m_canWrite = TRUE; + } + else if (mode & FILEMODE_APPEND) + { + fopenMode[0] = 'a'; + m_canWrite = TRUE; + } + if (mode & FILEMODE_BINARY && fopenMode[0] != '\0') + fopenMode[1] = 'b'; + + if (fopenMode[0] == '\0') + { + ASSERT(!"Unrecognized mode."); + return FALSE; + } + else + { + ASSERT(m_canRead == TRUE || m_canWrite == TRUE); + + m_fp = SDL_RWFromFile(filename.c_str(), fopenMode); + if (m_fp) + { + LOG_INFO(LOGCAT_FILEIO, "Opened SDLFile \"%s\", mode = %s\n", filename.c_str(), fopenMode); + m_mode = mode; + return TRUE; + } + else + { + LOG_WARN(LOGCAT_FILEIO, "Failed to open SDLFile \"%s\", mode = %s\n", filename.c_str(), fopenMode); + return FALSE; + } + } +} + +void SDLFile::Close() +{ + STACK_TRACE; + if (IsOpen()) + { + LOG_INFO(LOGCAT_FILEIO, "Closed SDLFIle \"%s\"\n", m_filename.c_str()); + SDL_FreeRW(m_fp); + } + + m_fp = NULL; + m_mode = 0; + m_canRead = FALSE; + m_canWrite = FALSE; + m_filename.clear(); +} + +int8_t SDLFile::ReadChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int8_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(int8_t), 1); + return buffer; +} + +uint8_t SDLFile::ReadUnsignedChar() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint8_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(uint8_t), 1); + return buffer; +} + +int16_t SDLFile::ReadShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int16_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(int16_t), 1); + return buffer; +} + +uint16_t SDLFile::ReadUnsignedShort() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint16_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(uint16_t), 1); + return buffer; +} + +int32_t SDLFile::ReadInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int32_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(int32_t), 1); + return buffer; +} + +uint32_t SDLFile::ReadUnsignedInt() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint32_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(uint32_t), 1); + return buffer; +} + +int64_t SDLFile::ReadLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + int64_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(int64_t), 1); + return buffer; +} + +uint64_t SDLFile::ReadUnsignedLong() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + uint64_t buffer; + SDL_RWread(m_fp, &buffer, sizeof(uint64_t), 1); + return buffer; +} + +float SDLFile::ReadFloat() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + float buffer; + SDL_RWread(m_fp, &buffer, sizeof(float), 1); + return buffer; +} + +double SDLFile::ReadDouble() +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + double buffer; + SDL_RWread(m_fp, &buffer, sizeof(double), 1); + return buffer; +} + +size_t SDLFile::Read(int8_t *buffer, size_t bytesToRead) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + ASSERT(buffer != NULL); + ASSERT(bytesToRead > 0); + size_t numRead = SDL_RWread(m_fp, buffer, bytesToRead, 1); + return (numRead * bytesToRead); +} + +size_t SDLFile::ReadString(stl::string &buffer) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + do + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + } while (c != '\0'); + + return charactersRead; +} + +size_t SDLFile::ReadFixedString(stl::string &buffer, size_t maxLength) +{ + ASSERT(IsOpen()); + ASSERT(CanRead()); + size_t charactersRead = 0; + int8_t c; + for (size_t i = 0; i < maxLength; ++i) + { + c = ReadChar(); + if (c) + { + buffer += c; + ++charactersRead; + } + if (c == '\0') + break; + } + + return charactersRead; +} + +size_t SDLFile::WriteChar(int8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(int8_t), 1); + return (numWritten * sizeof(int8_t)); +} + +size_t SDLFile::WriteUnsignedChar(uint8_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(uint8_t), 1); + return (numWritten * sizeof(uint8_t)); +} + +size_t SDLFile::WriteShort(int16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(int16_t), 1); + return (numWritten * sizeof(int16_t)); +} + +size_t SDLFile::WriteUnsignedShort(uint16_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(uint16_t), 1); + return (numWritten * sizeof(uint16_t)); +} + +size_t SDLFile::WriteInt(int32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(int32_t), 1); + return (numWritten * sizeof(int32_t)); +} + +size_t SDLFile::WriteUnsignedInt(uint32_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(uint32_t), 1); + return (numWritten * sizeof(uint32_t)); +} + +size_t SDLFile::WriteLong(int64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(int64_t), 1); + return (numWritten * sizeof(int64_t)); +} + +size_t SDLFile::WriteUnsignedLong(uint64_t data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(uint64_t), 1); + return (numWritten * sizeof(uint64_t)); +} + +size_t SDLFile::WriteFloat(float data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(float), 1); + return (numWritten * sizeof(float)); +} + +size_t SDLFile::WriteDouble(double data) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + size_t numWritten = SDL_RWwrite(m_fp, &data, sizeof(double), 1); + return (numWritten * sizeof(double)); +} + +size_t SDLFile::Write(int8_t *buffer, size_t bytesToWrite) +{ + ASSERT(IsOpen()); + ASSERT(CanWrite()); + ASSERT(buffer != NULL); + ASSERT(bytesToWrite > 0); + size_t numWritten = SDL_RWwrite(m_fp, buffer, bytesToWrite, 1); + return (numWritten * bytesToWrite); +} + +size_t SDLFile::Tell() +{ + ASSERT(IsOpen()); + return (size_t)SDL_RWtell(m_fp); +} + +void SDLFile::Seek(size_t offset, FileSeek from) +{ + ASSERT(IsOpen()); + + int origin = SEEK_CUR; + if (from == FILESEEK_BEGINNING) + origin = SEEK_SET; + else if (from == FILESEEK_END) + origin = SEEK_END; + + SDL_RWseek(m_fp, offset, origin); +} + +BOOL SDLFile::AtEOF() +{ + ASSERT(IsOpen()); + size_t filesize = GetFileSize(); + size_t currentPos = Tell(); + if (filesize == currentPos) + return TRUE; + else + return FALSE; +} + +size_t SDLFile::GetFileSize() +{ + ASSERT(IsOpen()); + size_t currentPos = Tell(); + Seek(0, FILESEEK_END); + size_t filesize = Tell(); + Seek(currentPos, FILESEEK_BEGINNING); + return filesize; +} +#endif diff --git a/src/framework/file/sdlfile.h b/src/framework/file/sdlfile.h new file mode 100644 index 0000000..96738d8 --- /dev/null +++ b/src/framework/file/sdlfile.h @@ -0,0 +1,68 @@ +#ifdef SDL +#ifndef __FRAMEWORK_FILE_SDLFILE_H_INCLUDED__ +#define __FRAMEWORK_FILE_SDLFILE_H_INCLUDED__ + +#include "../common.h" +#include "file.h" + +#include +#include "../sdlincludes.h" + +class SDLFile : public File +{ +public: + SDLFile(); + virtual ~SDLFile(); + + BOOL Open(const stl::string &filename, int mode); + void Close(); + + BOOL IsOpen() const { return m_fp != NULL; } + BOOL CanRead() const { return m_canRead; } + BOOL CanWrite() const { return m_canWrite; } + FileType GetFileType() const { return FILETYPE_IO; } + + int8_t ReadChar(); + uint8_t ReadUnsignedChar(); + int16_t ReadShort(); + uint16_t ReadUnsignedShort(); + int32_t ReadInt(); + uint32_t ReadUnsignedInt(); + int64_t ReadLong(); + uint64_t ReadUnsignedLong(); + float ReadFloat(); + double ReadDouble(); + size_t Read(int8_t *buffer, size_t bytesToRead); + size_t ReadString(stl::string &buffer); + size_t ReadFixedString(stl::string &buffer, size_t maxLength); + + size_t WriteChar(int8_t data); + size_t WriteUnsignedChar(uint8_t data); + size_t WriteShort(int16_t data); + size_t WriteUnsignedShort(uint16_t data); + size_t WriteInt(int32_t data); + size_t WriteUnsignedInt(uint32_t data); + size_t WriteLong(int64_t data); + size_t WriteUnsignedLong(uint64_t data); + size_t WriteFloat(float data); + size_t WriteDouble(double data); + size_t Write(int8_t *buffer, size_t bytesToWrite); + + size_t Tell(); + void Seek(size_t offset, FileSeek from); + BOOL AtEOF(); + size_t GetFileSize(); + + const stl::string& GetFilename() const { return m_filename; } + +private: + SDL_RWops *m_fp; + int m_mode; + BOOL m_canRead; + BOOL m_canWrite; + stl::string m_filename; +}; + +#endif +#endif + diff --git a/src/framework/file/sdlfilesystem.cpp b/src/framework/file/sdlfilesystem.cpp new file mode 100644 index 0000000..4bfc592 --- /dev/null +++ b/src/framework/file/sdlfilesystem.cpp @@ -0,0 +1,88 @@ +#ifdef SDL +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "sdlfilesystem.h" + +#include "file.h" +#include "filesystem.h" +#include "sdlfile.h" +#include "memoryfile.h" +#include "util.h" + +SDLFileSystem::SDLFileSystem() + : FileSystem() +{ + STACK_TRACE; + m_assetsPath = ::GetAssetsPath(); + LOG_INFO(LOGCAT_FILEIO, "FileSystem assets path is \"%s\".\n", m_assetsPath.c_str()); +} + +SDLFileSystem::~SDLFileSystem() +{ + STACK_TRACE; +} + +File* SDLFileSystem::Open(const stl::string &filename, int mode) +{ + STACK_TRACE; + File *result = NULL; + stl::string realFilename = TranslateFilePath(filename); + + if (mode & FILEMODE_MEMORY) + result = OpenMemory(realFilename, mode); + else + result = OpenFile(realFilename, mode); + + return result; +} + +File* SDLFileSystem::OpenFile(const stl::string &filename, int mode) +{ + STACK_TRACE; + SDLFile *file = new SDLFile(); + ASSERT(file != NULL); + + if (file->Open(filename, mode)) + return file; + else + { + SAFE_DELETE(file); + return NULL; + } +} + +File* SDLFileSystem::OpenMemory(const stl::string &filename, int mode) +{ + STACK_TRACE; + // open the specified file off the disk (or whatever) + File *file = OpenFile(filename, mode); + if (file == NULL) + return NULL; + + // read the entire file contents into memory + MemoryFile *memoryFile = new MemoryFile(); + ASSERT(memoryFile != NULL); + if (!memoryFile->Open(file)) + { + SAFE_DELETE(memoryFile); // sets NULL, so this returns NULL on failure + } + + // close the source file, we're done with it either way + file->Close(); + SAFE_DELETE(file); + + return memoryFile; +} + +stl::string SDLFileSystem::TranslateFilePath(const stl::string &filename) const +{ + STACK_TRACE; + if (filename.substr(0, 9) == "assets://") + return m_assetsPath + filename.substr(9); + else + return filename; +} +#endif + diff --git a/src/framework/file/sdlfilesystem.h b/src/framework/file/sdlfilesystem.h new file mode 100644 index 0000000..59558b0 --- /dev/null +++ b/src/framework/file/sdlfilesystem.h @@ -0,0 +1,31 @@ +#ifdef SDL +#ifndef __FRAMEWORK_FILE_SDLFILESYSTEM_H_INCLUDED__ +#define __FRAMEWORK_FILE_SDLFILESYSTEM_H_INCLUDED__ + +#include + +#include "filesystem.h" + +class File; + +class SDLFileSystem : public FileSystem +{ +public: + SDLFileSystem(); + virtual ~SDLFileSystem(); + + File* Open(const stl::string &filename, int mode); + + stl::string TranslateFilePath(const stl::string &filename) const; + const stl::string& GetAssetsPath() const { return m_assetsPath; } + +private: + File* OpenFile(const stl::string &filename, int mode); + File* OpenMemory(const stl::string &filename, int mode); + + stl::string m_assetsPath; +}; + +#endif +#endif + diff --git a/src/framework/file/util.cpp b/src/framework/file/util.cpp new file mode 100644 index 0000000..c0ad1e8 --- /dev/null +++ b/src/framework/file/util.cpp @@ -0,0 +1,153 @@ +#include "../debug.h" + +#include "util.h" +#ifndef MOBILE +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#define WIN32_EXTRA_LEAN +#include +#elif __linux__ +#include +#elif __APPLE__ +#include +#include +#include +#include +#else +#error Unsupported platform +#endif +#endif + +stl::string g_appPath; +stl::string g_assetsPath; + +const stl::string& GetAppPath() +{ + STACK_TRACE; + if (g_appPath.length() > 0) + return g_appPath; + +#ifndef MOBILE +#ifdef _WIN32 + char pathBuffer[MAX_PATH + 1]; + DWORD result = GetCurrentDirectoryA(MAX_PATH, pathBuffer); + ASSERT(result != 0); + if (!result) + return g_appPath; + + stl::string path = pathBuffer; + g_appPath = path + "\\"; +#elif __linux__ + // Code taken from: http://www.gamedev.net/community/forums/topic.asp?topic_id=459511 + stl::string path = ""; + pid_t pid = getpid(); + char buffer[20] = { 0 }; + sprintf(buffer, "%d", pid); + stl::string link = "/proc/"; + link.append(buffer); + link.append("/exe"); + char proc[512]; + int ch = readlink(link.c_str(), proc, 512); + if (ch != -1) + { + proc[ch] = 0; + path = proc; + stl::string::size_type t = path.find_last_of("/"); + path = path.substr(0, t); + } + g_appPath = path + "/"; +#elif __APPLE__ + uint32_t size = MAXPATHLEN; + char *pathBuffer = new char[size]; + int result = _NSGetExecutablePath(pathBuffer, &size); + if (result == -1) + { + delete[] pathBuffer; + pathBuffer = new char[size]; + result = _NSGetExecutablePath(pathBuffer, &size); + ASSERT(result == 0); + if (result == -1) + return g_appPath; // not sure why this would fail again (probably won't ever?) + } + // resolve symlinks (who cares .. ?) + char *realPathBuffer = realpath(pathBuffer, NULL); + ASSERT(realPathBuffer != NULL); + if (realPathBuffer == NULL) + return g_appPath; + + stl::string appPath = realPathBuffer; + delete[] pathBuffer; + free(realPathBuffer); + + // _NSGetExecutablePath actually returns the path to and including the + // currently running executable, but we just want the path containing the + // executable. + stl::string::size_type pos = appPath.find_last_of('/'); + ASSERT(pos != stl::string::npos); + g_appPath = appPath.substr(0, pos + 1); +#endif +#else + g_appPath = "./"; +#endif + return g_appPath; +} + +const stl::string& GetAssetsPath() +{ + STACK_TRACE; + if (g_assetsPath.length() > 0) + return g_assetsPath; + +#ifndef MOBILE +#if defined(_WIN32) || defined(__linux__) + g_assetsPath = GetAppPath() + "assets/"; +#elif __APPLE__ + stl::string appPath = GetAppPath(); + + // check if this binary is running from inside an app bundle directory + if (appPath.length() > 20 && appPath.substr(appPath.length() - 20) == ".app/Contents/MacOS/") + { + // binary is running inside an app bundle. first get the path to + // the "Contents" part of the app bundle + stl::string appBundleContentsPath = appPath.substr(0, appPath.length() - 6); + stl::string appBundleResourcesPath = appBundleContentsPath + "Resources"; + + // we need to first check if the app bundle's "Resources" directory + // exists, and if so, use that as the assets path. + // if it does not exists, use a path to an "assets" directory + // in the same directory containing the app bundle (that is, we + // treat the app bundle as if it were the actual binary itself + // and then put together the assets path like we do in Win/Linux) + struct stat sb; + if (stat(appBundleResourcesPath.c_str(), &sb) == 0 && S_ISDIR(sb.st_mode)) + { + // the "Resources" directory exists + g_assetsPath = appBundleResourcesPath + "/"; + } + else + { + // fall back to use a path to "assets" in the same directory as + // the main app bundle (".app") directory + + // get the directory that contains the app bundle + size_t p = appPath.rfind('/', appPath.length() - 20); + if (p == stl::string::npos) + // weird! this would mean that the app bundle is at the root + g_assetsPath = "/assets/"; + else + g_assetsPath = appPath.substr(0, p) + "/assets/"; + } + } + else + // just a standalone binary. no app bundle directory + g_assetsPath = appPath + "assets/"; +#endif +#else +#ifdef __S3E__ + g_assetsPath = GetAppPath(); +#else + g_assetsPath = GetAppPath() + "assets/"; +#endif +#endif + return g_assetsPath; +} diff --git a/src/framework/file/util.h b/src/framework/file/util.h new file mode 100644 index 0000000..3f98311 --- /dev/null +++ b/src/framework/file/util.h @@ -0,0 +1,16 @@ +#ifndef __FRAMEWORK_FILE_UTIL_H_INCLUDED__ +#define __FRAMEWORK_FILE_UTIL_H_INCLUDED__ + +#include + +/** + * @return the path to the currently running executable + */ +const stl::string& GetAppPath(); + +/** + * @return the path to the assets directory + */ +const stl::string& GetAssetsPath(); + +#endif diff --git a/src/framework/frameworkutils.cpp b/src/framework/frameworkutils.cpp new file mode 100644 index 0000000..3835885 --- /dev/null +++ b/src/framework/frameworkutils.cpp @@ -0,0 +1,18 @@ +#include "common.h" + +#include + +void SeedRnd(int32_t seed) +{ + srand(seed); +} + +int32_t Rnd(int32_t low, int32_t high) +{ + return rand() % ((high - low) + 1) + low; +} + +float Rnd(float low, float high) +{ + return low + (float)rand() / ((float)RAND_MAX / (high - low)); +} diff --git a/src/framework/gamewindow.h b/src/framework/gamewindow.h new file mode 100644 index 0000000..cc52941 --- /dev/null +++ b/src/framework/gamewindow.h @@ -0,0 +1,129 @@ +#ifndef __FRAMEWORK_GAMEWINDOW_H_INCLUDED__ +#define __FRAMEWORK_GAMEWINDOW_H_INCLUDED__ + +#include "common.h" +#include "math/rect.h" +#include "screenorientation.h" + +class BaseGameApp; +struct OSEvent; + +struct GameWindowParams +{ + BOOL windowed; +}; + +/** + * Interface for a game window management class which also manages + * it's associated graphics context. + */ +class GameWindow +{ +public: + GameWindow(BaseGameApp *gameApp) + { + m_gameApp = gameApp; + } + + virtual ~GameWindow() {} + + /** + * Creates the game window. + * @param params platform specific window creation parameters + * @return TRUE if successful, FALSE if not + */ + virtual BOOL Create(GameWindowParams *params) = 0; + + /** + * Resizes the window to the given dimensions. + * @param width the new window width + * @param height the new window height + * @return TRUE if successful, FALSE if not + */ + virtual BOOL Resize(uint16_t width, uint16_t height) = 0; + + /** + * Toggles between fullscreen and windowed mode. + * @return TRUE if successful, FALSE if not + */ + virtual BOOL ToggleFullscreen() = 0; + + /** + * Signals to the underlying system that the window should be closed + * as soon as possible. + */ + virtual void Close() = 0; + + /** + * @return the current width of the window's client area + */ + virtual uint16_t GetWidth() const = 0; + + /** + * @return the current height of the window's client area + */ + virtual uint16_t GetHeight() const = 0; + + /** + * @return the current dimensions of the window's client area + */ + virtual const Rect& GetRect() const = 0; + + /** + * @return the bits per pixel display format of the window's graphics context + */ + virtual uint8_t GetBPP() const = 0; + + /** + * @return TRUE if the current window is windowed, FALSE if fullscreen + */ + virtual BOOL IsWindowed() const = 0; + + /** + * @return the current display rotation angle + */ + virtual SCREEN_ORIENTATION_ANGLE GetScreenOrientation() const = 0; + + /** + * @return TRUE if this window is the currently active one + */ + virtual BOOL IsActive() const = 0; + + /** + * @return TRUE if this window currently is active and has input focus + */ + virtual BOOL IsFocused() const = 0; + + /** + * @return TRUE if the window has been signaled that it should close + */ + virtual BOOL IsClosing() const = 0; + + /** + * @return TRUe if the window currently has an active and usable OpenGL context associated with it + */ + virtual BOOL HasGLContext() const = 0; + + /** + * Performs platform specific processing for an event raised by the operating system. + * @param event the event arguments received by the operating system + */ + virtual void ProcessEvent(const OSEvent *event) = 0; + + /** + * Flips the display backbuffer to the frontbuffer. + */ + virtual void Flip() = 0; + +protected: + /** + * @return the parent game application object + */ + BaseGameApp* GetGameApp() { return m_gameApp; } + +private: + BaseGameApp *m_gameApp; + +}; + +#endif diff --git a/src/framework/graphics/billboardspritebatch.cpp b/src/framework/graphics/billboardspritebatch.cpp new file mode 100644 index 0000000..66c7d37 --- /dev/null +++ b/src/framework/graphics/billboardspritebatch.cpp @@ -0,0 +1,439 @@ +#include "../debug.h" + +#include "billboardspritebatch.h" + +#include +#include +#include + +#include "blendstate.h" +#include "graphicsdevice.h" +#include "renderstate.h" +#include "shader.h" +#include "spritefont.h" +#include "spriteshader.h" +#include "sprite3dshader.h" +#include "texture.h" +#include "textureatlas.h" +#include "vertexbuffer.h" +#include "viewcontext.h" +#include "../math/camera.h" +#include "../math/matrix4x4.h" +#include "../math/vector3.h" + +const uint32_t VERTICES_PER_SPRITE = 6; + +const size_t PRINTF_BUFFER_SIZE = 8096; +char __billboardSpriteBatch_PrintfBuffer[PRINTF_BUFFER_SIZE + 1]; + +BillboardSpriteBatch::BillboardSpriteBatch(GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + m_graphicsDevice = graphicsDevice; + m_shader = NULL; + + // TODO: default size of 1 is best? + m_currentSpriteCapacity = 1; + m_currentSpritePointer = 0; + + // size vertices and texture storage to match m_currentSpriteCapacity + m_vertices = new VertexBuffer(BUFFEROBJECT_USAGE_STREAM); + ASSERT(m_vertices != NULL); + m_vertices->AddAttribute(VERTEX_POS_3D); + m_vertices->AddAttribute(VERTEX_COLOR); + m_vertices->AddAttribute(VERTEX_TEXCOORD); + m_vertices->Create(m_currentSpriteCapacity * VERTICES_PER_SPRITE); + + m_textures.resize(m_currentSpriteCapacity); + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + + m_blendState = new BLENDSTATE_ALPHABLEND; + ASSERT(m_blendState != NULL); + + m_begunRendering = FALSE; + + m_isRenderStateOverridden = FALSE; + m_isBlendStateOverridden = FALSE; +} + +BillboardSpriteBatch::~BillboardSpriteBatch() +{ + STACK_TRACE; + SAFE_DELETE(m_vertices); + SAFE_DELETE(m_renderState); + SAFE_DELETE(m_blendState); +} + +void BillboardSpriteBatch::InternalBegin(const RenderState *renderState, const BlendState *blendState, SpriteShader *shader) +{ + STACK_TRACE; + ASSERT(m_begunRendering == FALSE); + + m_cameraPosition = m_graphicsDevice->GetViewContext()->GetCamera()->GetPosition(); + m_cameraForward = m_graphicsDevice->GetViewContext()->GetCamera()->GetForward(); + + if (shader == NULL) + m_shader = m_graphicsDevice->GetSprite3DShader(); + else + { + ASSERT(shader->IsReadyForUse() == TRUE); + m_shader = shader; + } + + if (renderState != NULL) + { + m_isRenderStateOverridden = TRUE; + m_overrideRenderState = *renderState; + } + else + m_isRenderStateOverridden = FALSE; + + if (blendState != NULL) + { + m_isBlendStateOverridden = TRUE; + m_overrideBlendState = *blendState; + } + else + m_isBlendStateOverridden = FALSE; + + m_currentSpritePointer = 0; + m_begunRendering = TRUE; +} + +void BillboardSpriteBatch::Begin(SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(NULL, NULL, shader); +} + +void BillboardSpriteBatch::Begin(const RenderState &renderState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(&renderState, NULL, shader); +} + +void BillboardSpriteBatch::Begin(const BlendState &blendState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(NULL, &blendState, shader); +} + +void BillboardSpriteBatch::Begin(const RenderState &renderState, const BlendState &blendState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(&renderState, &blendState, shader); +} + +void BillboardSpriteBatch::Render(const Texture *texture, float x, float y, float z, float width, float height, BILLBOARDSPRITE_TYPE type, const Color &color) +{ + STACK_TRACE; + AddSprite(type, texture, Vector3(x, y, z), width, height, 0, 0, texture->GetWidth(), texture->GetHeight(), color); +} + +void BillboardSpriteBatch::Render(const Texture *texture, const Vector3 &position, float width, float height, BILLBOARDSPRITE_TYPE type, const Color &color) +{ + STACK_TRACE; + AddSprite(type, texture, position, width, height, 0, 0, texture->GetWidth(), texture->GetHeight(), color); +} + +void BillboardSpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, float x, float y, float z, float width, float height, BILLBOARDSPRITE_TYPE type, const Color &color) +{ + STACK_TRACE; + const RectF *texCoords = &atlas->GetTile(index).texCoords; + const Texture *texture = atlas->GetTexture(); + + AddSprite(type, texture, Vector3(x, y, z), width, height, texCoords->left, texCoords->top, texCoords->right, texCoords->bottom, color); +} + +void BillboardSpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &position, float width, float height, BILLBOARDSPRITE_TYPE type, const Color &color) +{ + STACK_TRACE; + const RectF *texCoords = &atlas->GetTile(index).texCoords; + const Texture *texture = atlas->GetTexture(); + + AddSprite(type, texture, position, width, height, texCoords->left, texCoords->top, texCoords->right, texCoords->bottom, color); +} + +void BillboardSpriteBatch::Render(const SpriteFont *font, float x, float y, float z, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *text) +{ + STACK_TRACE; + Render(font, Vector3(x, y, z), type, color, pixelScale, text); +} + +void BillboardSpriteBatch::Render(const SpriteFont *font, const Vector3 &position, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *text) +{ + STACK_TRACE; + size_t textLength = strlen(text); + + uint16_t textWidth = 0; + uint16_t textHeight = 0; + font->MeasureString(&textWidth, &textHeight, text); + + // the x,y,z coordinate specified is used as the position to center the + // text billboard around. we start drawing the text at the top-left of this + float startX = -(float)((textWidth / 2) * pixelScale); + float startY = -(float)((textHeight / 2) * pixelScale); + + float drawX = startX; + float drawY = startY; + float lineHeight = (float)(font->GetLetterHeight() * pixelScale); + + Matrix4x4 transform = GetTransformFor(type, position); + + for (size_t i = 0; i < textLength; ++i) + { + char c = text[i]; + if (c == '\n') + { + // new line + drawX = startX; + drawY += lineHeight; + } + else + { + const TextureAtlasTile &glyph = font->GetGlyph(c); + float glyphWidth = (float)(glyph.dimensions.GetWidth() * pixelScale); + float glyphHeight = (float)(glyph.dimensions.GetHeight() * pixelScale); + + AddSprite( + type, + transform, + font->GetTexture(), + Vector3(-drawX, -drawY, 0.0f), + glyphWidth, glyphHeight, + glyph.texCoords.left, glyph.texCoords.top, glyph.texCoords.right, glyph.texCoords.bottom, + color + ); + + drawX += glyphWidth; + } + } +} + +void BillboardSpriteBatch::Printf(const SpriteFont *font, float x, float y, float z, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__billboardSpriteBatch_PrintfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, Vector3(x, y, z), type, color, pixelScale, __billboardSpriteBatch_PrintfBuffer); +} + +void BillboardSpriteBatch::Printf(const SpriteFont *font, const Vector3 &position, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__billboardSpriteBatch_PrintfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, position, type, color, pixelScale, __billboardSpriteBatch_PrintfBuffer); +} + +void BillboardSpriteBatch::AddSprite(BILLBOARDSPRITE_TYPE type, const Texture *texture, const Vector3 &position, float width, float height, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + Matrix4x4 transform = GetTransformFor(type, position); + + // zero vector offset as the transform will translate the billboard to + // the specified position + AddSprite(type, transform, texture, ZERO_VECTOR, width, height, sourceLeft, sourceTop, sourceRight, sourceBottom, color); +} + +void BillboardSpriteBatch::AddSprite(BILLBOARDSPRITE_TYPE type, const Texture *texture, const Vector3 &position, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + Matrix4x4 transform = GetTransformFor(type, position); + + // zero vector offset as the transform will translate the billboard to + // the specified position + AddSprite(type, transform, texture, ZERO_VECTOR, width, height, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); +} + +void BillboardSpriteBatch::AddSprite(BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + uint16_t sourceWidth = sourceRight - sourceLeft; + ASSERT(sourceWidth > 0); + uint16_t sourceHeight = sourceBottom - sourceTop; + ASSERT(sourceHeight > 0); + float texLeft = sourceLeft / (float)sourceWidth; + float texTop = sourceTop / (float)sourceHeight; + float texRight = sourceRight / (float)sourceWidth; + float texBottom = sourceBottom / (float)sourceHeight; + + CheckForNewSpriteSpace(); + SetSpriteInfo(m_currentSpritePointer, type, transform, texture, offset, width, height, texLeft, texTop, texRight, texBottom, color); + ++m_currentSpritePointer; +} + +void BillboardSpriteBatch::AddSprite(BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + CheckForNewSpriteSpace(); + SetSpriteInfo(m_currentSpritePointer, type, transform, texture, offset, width, height, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); + ++m_currentSpritePointer; +} + +void BillboardSpriteBatch::SetSpriteInfo(uint32_t spriteIndex, BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + uint32_t base = spriteIndex * VERTICES_PER_SPRITE; + + float halfWidth = width / 2.0f; + float halfHeight = height / 2.0f; + + // TODO: needed to reverse this, and my brain isn't working atm to figure out why + // leaves me feeling like I'm doing something wrong elsewhere... + float left = halfWidth; + float top = -halfHeight; + float right = -halfWidth; + float bottom = halfHeight; + + // HACK: I don't like this at all. I'm also not sure how this is + // performance-wise (haven't tested as I write this). Ideally in the + // future this will be done by a custom shader using OpenGL/ES 2... + Vector3 v1 = (Vector3(left, top, 0.0f) + offset) * transform; + Vector3 v2 = (Vector3(right, top, 0.0f) + offset) * transform; + Vector3 v3 = (Vector3(right, bottom, 0.0f) + offset) * transform; + Vector3 v4 = (Vector3(left, top, 0.0f) + offset) * transform; + Vector3 v5 = (Vector3(right, bottom, 0.0f) + offset) * transform; + Vector3 v6 = (Vector3(left, bottom, 0.0f) + offset) * transform; + + m_vertices->SetPosition3(base, v1); + m_vertices->SetPosition3(base + 1, v2); + m_vertices->SetPosition3(base + 2, v3); + m_vertices->SetPosition3(base + 3, v4); + m_vertices->SetPosition3(base + 4, v5); + m_vertices->SetPosition3(base + 5, v6); + + m_vertices->SetTexCoord(base, texCoordLeft, texCoordBottom); + m_vertices->SetTexCoord(base + 1, texCoordRight, texCoordBottom); + m_vertices->SetTexCoord(base + 2, texCoordRight, texCoordTop); + m_vertices->SetTexCoord(base + 3, texCoordLeft, texCoordBottom); + m_vertices->SetTexCoord(base + 4, texCoordRight, texCoordTop); + m_vertices->SetTexCoord(base + 5, texCoordLeft, texCoordTop); + + m_vertices->SetColor(base, color); + m_vertices->SetColor(base + 1, color); + m_vertices->SetColor(base + 2, color); + m_vertices->SetColor(base + 3, color); + m_vertices->SetColor(base + 4, color); + m_vertices->SetColor(base + 5, color); + + m_textures[spriteIndex] = texture; +} + +void BillboardSpriteBatch::End() +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + if (m_isRenderStateOverridden) + m_overrideRenderState.Apply(); + else + m_renderState->Apply(); + if (m_isBlendStateOverridden) + m_overrideBlendState.Apply(); + else + m_blendState->Apply(); + + m_graphicsDevice->BindShader(m_shader); + m_shader->SetModelViewMatrix(m_graphicsDevice->GetViewContext()->GetModelViewMatrix()); + m_shader->SetProjectionMatrix(m_graphicsDevice->GetViewContext()->GetProjectionMatrix()); + RenderQueue(); + m_graphicsDevice->UnbindShader(); + + m_begunRendering = FALSE; +} + +void BillboardSpriteBatch::RenderQueue() +{ + STACK_TRACE; + m_graphicsDevice->BindVertexBuffer(m_vertices); + + const Texture *currentTexture = NULL; + uint32_t startOffset = 0; + uint32_t stopOffset = 0; + + for (uint32_t i = 0; i < m_currentSpritePointer; ++i) + { + if (currentTexture != m_textures[i]) + { + if (currentTexture != NULL) + { + // render the range for the current texture + RenderQueueRange(currentTexture, startOffset, stopOffset); + } + + // switch to the new texture and begin the new range + currentTexture = m_textures[i]; + startOffset = i; + stopOffset = startOffset; + } + ++stopOffset; + } + if (currentTexture != NULL) + RenderQueueRange(currentTexture, startOffset, stopOffset); + + m_graphicsDevice->UnbindVertexBuffer(); +} + +void BillboardSpriteBatch::RenderQueueRange(const Texture *texture, uint32_t firstSprite, uint32_t lastSprite) +{ + STACK_TRACE; + const int TRIANGLES_PER_SPRITE = 2; + uint32_t vertexOffset = firstSprite * VERTICES_PER_SPRITE; + uint32_t numTriangles = (lastSprite - firstSprite) * TRIANGLES_PER_SPRITE; + + m_graphicsDevice->BindTexture(texture); + m_shader->SetTextureHasAlphaOnly(texture->GetFormat() == TEXTURE_FORMAT_ALPHA); + m_graphicsDevice->RenderTriangles(vertexOffset, numTriangles); +} + +inline Matrix4x4 BillboardSpriteBatch::GetTransformFor(BILLBOARDSPRITE_TYPE type, const Vector3 &position) const +{ + Matrix4x4 out; + + switch (type) + { + case BILLBOARDSPRITE_SPHERICAL: + out = Matrix4x4::CreateBillboard(position, m_cameraPosition, UP, m_cameraForward); + break; + case BILLBOARDSPRITE_CYLINDRICAL: + out = Matrix4x4::CreateCylindricalBillboard(position, m_cameraPosition, m_cameraForward, Y_AXIS); + break; + case BILLBOARDSPRITE_SCREENALIGNED: + out = Matrix4x4::CreateScreenAlignedBillboard(position, UP, m_cameraForward); + break; + case BILLBOARDSPRITE_SCREENANDAXISALIGNED: + out = Matrix4x4::CreateScreenAndAxisAlignedBillboard(position, m_cameraForward, Y_AXIS); + break; + } + + return out; +} + +void BillboardSpriteBatch::CheckForNewSpriteSpace() +{ + STACK_TRACE; + // m_currentSpritePointer = zero-based index + // m_currentSpriteCapacity = count of items (not zero-based) + if (m_currentSpritePointer >= m_currentSpriteCapacity) + { + // increase capacity by one + ++m_currentSpriteCapacity; + m_vertices->Extend(VERTICES_PER_SPRITE); + m_textures.resize(m_currentSpriteCapacity); + } +} + diff --git a/src/framework/graphics/billboardspritebatch.h b/src/framework/graphics/billboardspritebatch.h new file mode 100644 index 0000000..8382f85 --- /dev/null +++ b/src/framework/graphics/billboardspritebatch.h @@ -0,0 +1,218 @@ +#ifndef __FRAMEWORK_GRAPHICS_BILLBOARDSPRITEBATCH_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_BILLBOARDSPRITEBATCH_H_INCLUDED__ + +#include "../common.h" +#include "blendstate.h" +#include "color.h" +#include "renderstate.h" +#include "../math/vector3.h" +#include + +class GraphicsDevice; +class SpriteFont; +class SpriteShader; +class Texture; +class TextureAtlas; +class VertexBuffer; +struct Matrix4x4; + +enum BILLBOARDSPRITE_TYPE +{ + BILLBOARDSPRITE_SPHERICAL, + BILLBOARDSPRITE_CYLINDRICAL, + BILLBOARDSPRITE_SCREENALIGNED, + BILLBOARDSPRITE_SCREENANDAXISALIGNED +}; + +/** + * Wrapper for 3D sprite and text rendering as billboards. + */ +class BillboardSpriteBatch +{ +public: + /** + * Creates a billboard sprite batch object. + * @param graphicsDevice the graphics device to perform rendering with + */ + BillboardSpriteBatch(GraphicsDevice *graphicsDevice); + + virtual ~BillboardSpriteBatch(); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param renderState custom render state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const RenderState &renderState, SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param blendState custom blend state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const BlendState &blendState, SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param renderState custom render state to use for rendering + * @param blendState custom blend state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const RenderState &renderState, const BlendState &blendState, SpriteShader *shader = NULL); + + /** + * Renders a texture as a billboard. The billboard will be centered on + * the coordinates provided. + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param z Z coordinate to render at + * @param width width to render the billboard at + * @param height height to render the billboard at + * @param type the type of billboard to render this texture as + * @param color color to tint the texture with + */ + void Render(const Texture *texture, float x, float y, float z, float width, float height, BILLBOARDSPRITE_TYPE type = BILLBOARDSPRITE_SPHERICAL, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a billboard. The billboard will be centered on + * the coordinates provided. + * @param position position to render at + * @param width width to render the billboard at + * @param height height to render the billboard at + * @param type the type of billboard to render this texture as + * @param color color to tint the texture with + */ + void Render(const Texture *texture, const Vector3 &position, float width, float height, BILLBOARDSPRITE_TYPE type = BILLBOARDSPRITE_SPHERICAL, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a billboard. The billboard + * will be centered on the coordinates provided. + * @param index the index of the sub-texture / tile to render + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param z Z coordinate to render at + * @param width width to render the billboard at + * @param height height to render the billboard at + * @param type the type of billboard to render this texture as + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, float x, float y, float z, float width, float height, BILLBOARDSPRITE_TYPE type = BILLBOARDSPRITE_SPHERICAL, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a billboard. The billboard + * will be centered on the coordinates provided. + * @param index the index of the sub-texture / tile to render + * @param position position to render at + * @param width width to render the billboard at + * @param height height to render the billboard at + * @param type the type of billboard to render this texture as + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &position, float width, float height, BILLBOARDSPRITE_TYPE type = BILLBOARDSPRITE_SPHERICAL, const Color &color = COLOR_WHITE); + + /** + * Renders text as series of billboards. The text will be centered on + * the coordinates provided. + * @param font the font to render with + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param z Z coordinate to render at + * @param type the type of billboard to render the text billboards as + * @param color the color to render the text in + * @param pixelScale scale factor applied to each pixel of the font texture + * to get the final text render size + * @param text the string of text to render + */ + void Render(const SpriteFont *font, float x, float y, float z, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *text); + + /** + * Renders text as series of billboards. The text will be centered on + * the coordinates provided. + * @param font the font to render with + * @param position position to render at + * @param type the type of billboard to render the text billboards as + * @param color the color to render the text in + * @param pixelScale scale factor applied to each pixel of the font texture + * to get the final text render size + * @param text the string of text to render + */ + void Render(const SpriteFont *font, const Vector3 &position, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *text); + + /** + * Renders formatted text as series of billboards. The text will be + * centered on the coordinates provided. + * @param font the font to render with + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param z Z coordinate to render at + * @param type the type of billboard to render the text billboards as + * @param color the color to render the text in + * @param pixelScale scale factor applied to each pixel of the font texture + * to get the final text render size + * @param format the string of text to render + */ + void Printf(const SpriteFont *font, float x, float y, float z, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *format, ...); + + /** + * Renders formatted text as series of billboards. The text will be + * centered on the coordinates provided. + * @param font the font to render with + * @param position position to render at + * @param type the type of billboard to render the text billboards as + * @param color the color to render the text in + * @param pixelScale scale factor applied to each pixel of the font texture + * to get the final text render size + * @param text the string of text to render + */ + void Printf(const SpriteFont *font, const Vector3 &position, BILLBOARDSPRITE_TYPE type, const Color &color, float pixelScale, const char *format, ...); + + /** + * Ends a rendering block, flushing out all rendering calls made + * since the Begin() call to the video card. + */ + void End(); + +private: + void Initialize(GraphicsDevice *graphicsDevice, uint16_t maxSprites); + void InternalBegin(const RenderState *renderState, const BlendState *blendState, SpriteShader *shader); + void AddSprite(BILLBOARDSPRITE_TYPE type, const Texture *texture, const Vector3 &position, float width, float height, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color); + void AddSprite(BILLBOARDSPRITE_TYPE type, const Texture *texture, const Vector3 &position, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + void AddSprite(BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color); + void AddSprite(BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + void SetSpriteInfo(uint32_t spriteIndex, BILLBOARDSPRITE_TYPE type, const Matrix4x4 &transform, const Texture *texture, const Vector3 &offset, float width, float height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + void RenderQueue(); + void RenderQueueRange(const Texture *texture, uint32_t firstSprite, uint32_t lastSprite); + + Matrix4x4 GetTransformFor(BILLBOARDSPRITE_TYPE type, const Vector3 &position) const; + void CheckForNewSpriteSpace(); + + uint32_t m_currentSpriteCapacity; + GraphicsDevice *m_graphicsDevice; + SpriteShader *m_shader; + RenderState *m_renderState; + BlendState *m_blendState; + BOOL m_isRenderStateOverridden; + RenderState m_overrideRenderState; + BOOL m_isBlendStateOverridden; + BlendState m_overrideBlendState; + VertexBuffer *m_vertices; + stl::vector m_textures; + uint32_t m_currentSpritePointer; + + Vector3 m_cameraPosition; + Vector3 m_cameraForward; + + BOOL m_begunRendering; +}; + +#endif diff --git a/src/framework/graphics/blendstate.cpp b/src/framework/graphics/blendstate.cpp new file mode 100644 index 0000000..574e8e1 --- /dev/null +++ b/src/framework/graphics/blendstate.cpp @@ -0,0 +1,68 @@ +#include "../debug.h" + +#include "blendstate.h" + +#include "glincludes.h" +#include "glutils.h" + +BlendState::BlendState() +{ + STACK_TRACE; + Initialize(); +} + +BlendState::BlendState(BLEND_FACTOR sourceFactor, BLEND_FACTOR destinationFactor) +{ + STACK_TRACE; + Initialize(); + + m_blending = TRUE; + m_sourceBlendFactor = sourceFactor; + m_destBlendFactor = destinationFactor; +} + +BlendState::~BlendState() +{ + STACK_TRACE; +} + +void BlendState::Initialize() +{ + STACK_TRACE; + m_blending = FALSE; + m_sourceBlendFactor = ONE; + m_destBlendFactor = ZERO; +} + +void BlendState::Apply() const +{ + STACK_TRACE; + if (m_blending) + { + GL_CALL(glEnable(GL_BLEND)); + int source = FindBlendFactorValue(m_sourceBlendFactor); + int dest = FindBlendFactorValue(m_destBlendFactor); + GL_CALL(glBlendFunc(source, dest)); + } + else + GL_CALL(glDisable(GL_BLEND)); +} + +int BlendState::FindBlendFactorValue(BLEND_FACTOR factor) const +{ + STACK_TRACE; + switch (factor) + { + case ZERO: return GL_ZERO; + case ONE: return GL_ONE; + case SRC_COLOR: return GL_SRC_COLOR; + case INVERSE_SRC_COLOR: return GL_ONE_MINUS_SRC_COLOR; + case DST_COLOR: return GL_DST_COLOR; + case INVERSE_DST_COLOR: return GL_ONE_MINUS_DST_COLOR; + case SRC_ALPHA: return GL_SRC_ALPHA; + case INVERSE_SRC_ALPHA: return GL_ONE_MINUS_SRC_ALPHA; + case DST_ALPHA: return GL_DST_ALPHA; + case INVERSE_DST_ALPHA: return GL_ONE_MINUS_DST_ALPHA; + default: return GL_SRC_ALPHA_SATURATE; + } +} diff --git a/src/framework/graphics/blendstate.h b/src/framework/graphics/blendstate.h new file mode 100644 index 0000000..cc4bb73 --- /dev/null +++ b/src/framework/graphics/blendstate.h @@ -0,0 +1,92 @@ +#ifndef __FRAMEWORK_GRAPHICS_BLENDSTATE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_BLENDSTATE_H_INCLUDED__ + +#include "../common.h" + +enum BLEND_FACTOR +{ + ZERO, + ONE, + SRC_COLOR, + INVERSE_SRC_COLOR, + DST_COLOR, + INVERSE_DST_COLOR, + SRC_ALPHA, + INVERSE_SRC_ALPHA, + DST_ALPHA, + INVERSE_DST_ALPHA, + SRC_ALPHA_SATURATION +}; + +/** + * Wraps blending settings for OpenGL. Instances of this class can be initialized + * and then used later on during execution to quickly apply a set of blend states. + */ +class BlendState +{ +public: + /** + * Creates a new blend state object with default settings matching OpenGL's + * initial settings. + */ + BlendState(); + + /** + * Creates a new blend state object with default settings matching OpenGL's + * initial settings except for those specified. + * @param sourceFactor source blend factor + * @param destinationFactor destination blend factor + */ + BlendState(BLEND_FACTOR sourceFactor, BLEND_FACTOR destinationFactor); + + virtual ~BlendState(); + + /** + * Applies blend states to the current OpenGL context. + */ + void Apply() const; + + /** + * @return TRUE if blending is enabled + */ + BOOL GetBlending() const { return m_blending; } + + /** + * @return the source blending factor + */ + BLEND_FACTOR GetSourceBlendFactor() const { return m_sourceBlendFactor; } + + /** + * @return the destination blending factor + */ + BLEND_FACTOR GetDestBlendFactor() const { return m_destBlendFactor; } + + /** + * Toggles blending on/off. + */ + void SetBlending(BOOL enable) { m_blending = enable; } + + /** + * Sets the source blending factor. + */ + void SetSourceBlendFactor(BLEND_FACTOR factor) { m_sourceBlendFactor = factor; } + + /** + * Sets the destination blending factor. + */ + void SetDestBlendFactor(BLEND_FACTOR factor) { m_destBlendFactor = factor; } + +private: + void Initialize(); + int FindBlendFactorValue(BLEND_FACTOR factor) const; + + BOOL m_blending; + BLEND_FACTOR m_sourceBlendFactor; + BLEND_FACTOR m_destBlendFactor; +}; + +#define BLENDSTATE_DEFAULT BlendState() +#define BLENDSTATE_OPAQUE BlendState() +#define BLENDSTATE_ALPHABLEND BlendState(SRC_ALPHA, INVERSE_SRC_ALPHA) + +#endif diff --git a/src/framework/graphics/bufferobject.cpp b/src/framework/graphics/bufferobject.cpp new file mode 100644 index 0000000..5fb21be --- /dev/null +++ b/src/framework/graphics/bufferobject.cpp @@ -0,0 +1,162 @@ +#include "../debug.h" + +#include "bufferobject.h" +#include "glincludes.h" +#include "glutils.h" + +BufferObject::BufferObject(BUFFEROBJECT_TYPE type, BUFFEROBJECT_USAGE usage) +{ + STACK_TRACE; + m_type = type; + m_usage = usage; + m_bufferId = 0; + m_isDirty = FALSE; + m_sizeInBytes = 0; +} + +BufferObject::~BufferObject() +{ + STACK_TRACE; + if (!IsClientSideBuffer()) + FreeBufferObject(); +} + +void BufferObject::CreateInVRAM() +{ + STACK_TRACE; + ASSERT(IsClientSideBuffer() == TRUE); + CreateBufferObject(); +} + +void BufferObject::RecreateInVRAM() +{ + STACK_TRACE; + ASSERT(IsClientSideBuffer() == FALSE); + FreeBufferObject(); + CreateBufferObject(); +} + +void BufferObject::FreeFromVRAM() +{ + STACK_TRACE; + ASSERT(IsClientSideBuffer() == FALSE); + FreeBufferObject(); +} + +void BufferObject::CreateBufferObject() +{ + STACK_TRACE; + GL_CALL(glGenBuffers(1, &m_bufferId)); + SizeBufferObject(); + + m_isDirty = TRUE; +} + +void BufferObject::FreeBufferObject() +{ + STACK_TRACE; + ASSERT(m_bufferId != 0); + GL_CALL(glDeleteBuffers(1, &m_bufferId)); + + m_bufferId = 0; + m_isDirty = FALSE; + m_sizeInBytes = 0; +} + +void BufferObject::Update() +{ + STACK_TRACE; + ASSERT(IsClientSideBuffer() == FALSE); + ASSERT(IsDirty() == TRUE); + ASSERT(GetNumElements() > 0); + ASSERT(GetElementWidthInBytes() > 0); + + size_t currentSizeInBytes = GetNumElements() * GetElementWidthInBytes(); + + GLenum usage = 0; + if (m_usage == BUFFEROBJECT_USAGE_STATIC) + usage = GL_STATIC_DRAW; + else if (m_usage == BUFFEROBJECT_USAGE_STREAM) + usage = GL_STREAM_DRAW; + else if (m_usage == BUFFEROBJECT_USAGE_DYNAMIC) + usage = GL_DYNAMIC_DRAW; + ASSERT(usage != 0); + + GLenum target = 0; + if (m_type == BUFFEROBJECT_TYPE_INDEX) + target = GL_ELEMENT_ARRAY_BUFFER; + else if (m_type == BUFFEROBJECT_TYPE_VERTEX) + target = GL_ARRAY_BUFFER; + ASSERT(target != 0); + + GL_CALL(glBindBuffer(target, m_bufferId)); + + if (m_sizeInBytes != currentSizeInBytes) + { + // means that the buffer object hasn't been allocated. So let's allocate and update at the same time + // figure out the size... + m_sizeInBytes = currentSizeInBytes; + + // and then allocate + update + GL_CALL(glBufferData(target, m_sizeInBytes, GetBuffer(), usage)); + } + else + { + // possible performance enhancement? passing a NULL pointer to + // glBufferData tells the driver that we don't care about the buffer's + // previous contents allowing it to do some extra optimizations which is + // fine since our glBufferSubData call is going to completely replace + // the contents anyway + GL_CALL(glBufferData(target, m_sizeInBytes, NULL, usage)); + + GL_CALL(glBufferSubData(target, 0, m_sizeInBytes, GetBuffer())); + } + + GL_CALL(glBindBuffer(target, 0)); + + m_isDirty = FALSE; +} + +void BufferObject::SizeBufferObject() +{ + STACK_TRACE; + ASSERT(IsClientSideBuffer() == FALSE); + ASSERT(GetNumElements() > 0); + ASSERT(GetElementWidthInBytes() > 0); + + GLenum usage = 0; + if (m_usage == BUFFEROBJECT_USAGE_STATIC) + usage = GL_STATIC_DRAW; + else if (m_usage == BUFFEROBJECT_USAGE_STREAM) + usage = GL_STREAM_DRAW; + else if (m_usage == BUFFEROBJECT_USAGE_DYNAMIC) + usage = GL_DYNAMIC_DRAW; + ASSERT(usage != 0); + + GLenum target = 0; + if (m_type == BUFFEROBJECT_TYPE_INDEX) + target = GL_ELEMENT_ARRAY_BUFFER; + else if (m_type == BUFFEROBJECT_TYPE_VERTEX) + target = GL_ARRAY_BUFFER; + ASSERT(target != 0); + + m_sizeInBytes = GetNumElements() * GetElementWidthInBytes(); + + // resize the buffer object without initializing it's data + GL_CALL(glBindBuffer(target, m_bufferId)); + GL_CALL(glBufferData(target, m_sizeInBytes, NULL, usage)); + GL_CALL(glBindBuffer(target, 0)); + + m_isDirty = TRUE; +} + +void BufferObject::OnNewContext() +{ + STACK_TRACE; + RecreateInVRAM(); +} + +void BufferObject::OnLostContext() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/bufferobject.h b/src/framework/graphics/bufferobject.h new file mode 100644 index 0000000..b307896 --- /dev/null +++ b/src/framework/graphics/bufferobject.h @@ -0,0 +1,126 @@ +#ifndef __FRAMEWORK_GRAPHICS_BUFFEROBJECT_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_BUFFEROBJECT_H_INCLUDED__ + +#include "../common.h" +#include "graphicscontextresource.h" + +enum BUFFEROBJECT_TYPE +{ + BUFFEROBJECT_TYPE_VERTEX = 0, + BUFFEROBJECT_TYPE_INDEX = 1 +}; + +enum BUFFEROBJECT_USAGE +{ + BUFFEROBJECT_USAGE_STATIC = 0, + BUFFEROBJECT_USAGE_STREAM = 1, + BUFFEROBJECT_USAGE_DYNAMIC = 2 +}; + +/** + * Base class for buffer objects that are able to store their data in a + * buffer object in video memory. + */ +class BufferObject : public GraphicsContextResource +{ +public: + /** + * Initializes buffer object handling state + * @param type the type of buffer object describing the kind of data that + * will be stored in it + * @param usage the expected usage pattern of this buffer object + */ + BufferObject(BUFFEROBJECT_TYPE type, BUFFEROBJECT_USAGE usage); + + virtual ~BufferObject(); + + /** + * @return TRUE if this buffer object is holding client side data only + * (hasn't been created as a buffer object in video memory) + */ + BOOL IsClientSideBuffer() const { return m_bufferId == 0; } + + /** + * @return the type of data this buffer holds + */ + BUFFEROBJECT_TYPE GetType() const { return m_type; } + + /** + * @return the expected usage pattern of this buffer object + */ + BUFFEROBJECT_USAGE GetUsage() const { return m_usage; } + + /** + * @return the size in bytes of this buffer object (including it's data) + */ + size_t GetSizeInBytes() const { return m_sizeInBytes; } + + /** + * @return the number of elements contained in this buffer object + */ + virtual uint32_t GetNumElements() const = 0; + + /** + * @return the size in bytes of each element of data in this buffer object + */ + virtual size_t GetElementWidthInBytes() const = 0; + + /** + * Creates a buffer object in video memory but does not upload this + * buffer's data there yet.This only allocates the buffer object in + * video memory. + */ + void CreateInVRAM(); + + /** + * Recreates the buffer object in video memory but does not upload this + * buffer's data there yet. This only reallocates the buffer object in + * video memory. + */ + void RecreateInVRAM(); + + /** + * Frees the buffer object from video memory. + */ + void FreeFromVRAM(); + + /** + * @return TRUE if some or all of the buffer data has been changed since + * the last Update() call + */ + BOOL IsDirty() const { return m_isDirty; } + + /** + * Uploads the current buffer data to video memory. + */ + void Update(); + + /** + * @return pointer to this buffer object's raw data + */ + virtual const void* GetBuffer() const = 0; + + /** + * @return the OpenGL buffer object ID for this buffer + */ + uint32_t GetBufferId() const { return m_bufferId; } + + void OnNewContext(); + void OnLostContext(); + +protected: + void CreateBufferObject(); + void FreeBufferObject(); + void SizeBufferObject(); + void SetDirty() { m_isDirty = TRUE; } + +private: + + BUFFEROBJECT_TYPE m_type; + BUFFEROBJECT_USAGE m_usage; + uint32_t m_bufferId; + BOOL m_isDirty; + size_t m_sizeInBytes; +}; + +#endif diff --git a/src/framework/graphics/color.h b/src/framework/graphics/color.h new file mode 100644 index 0000000..7c27a14 --- /dev/null +++ b/src/framework/graphics/color.h @@ -0,0 +1,200 @@ +#ifndef __FRAMEWORK_GRAPHICS_COLOR_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_COLOR_H_INCLUDED__ + +#include "../common.h" + +const float COLOR_ALPHA_TRANSPARENT = 0.0f; +const float COLOR_ALPHA_OPAQUE = 1.0f; +const uint8_t COLOR_ALPHA_TRANSPARENT_INT = 0; +const uint8_t COLOR_ALPHA_OPAQUE_INT = 255; + +/** + * Stores the RGBA components of a color and contains methods for easy + * conversion of various other representations of a color. + */ +struct Color +{ + /** + * Creates a new color, initialized to opaque black. + */ + Color(); + + /** + * Creates a new color. + * @param red the red component + * @param green the green component + * @param blue the blue component + * @param alpha the alpha component + */ + Color(float red, float green, float blue, float alpha = COLOR_ALPHA_OPAQUE); + + /** + * Creates a new color. + * @param red the red component (0-255) + * @param green the green component (0-255) + * @param blue the blue component (0-255) + * @param alpha the alpha component (0-255) + */ + Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = COLOR_ALPHA_OPAQUE_INT); + + /** + * @return a 32-bit hex representation of this color + */ + uint32_t ToInt() const; + + /** + * Converts and returns the RGBA color components to their integer + * (0-255) equivalents. + * @param out_r will contain the red component as an integer if not NULL + * @param out_g will contain the green component as an integer if not NULL + * @param out_b will contain the blue component as an integer if not NULL + * @param out_a will contain the alpha component as an integer if not NULL + */ + void ToInts(uint8_t *out_r, uint8_t *out_g, uint8_t *out_b, uint8_t *out_a) const; + + /** + * Extracts the individual RGBA components out of a 32-bit hex + * representation of a color as integers (0-255). + * @param color the 32-bit hex color value + * @param out_r will contain the red component as an integer if not NULL + * @param out_g will contain the green component as an integer if not NULL + * @param out_b will contain the blue component as an integer if not NULL + * @param out_a will contain the alpha component as an integer if not NULL + */ + static void FromInt(uint32_t color, uint8_t *out_r, uint8_t *out_g, uint8_t *out_b, uint8_t *out_a); + + /** + * Extracts the individual RGBA components out of a 32-bit hex + * representation of a color. + * @param color the 32-bit hex color value + * @param out_r will contain the red component if not NULL + * @param out_g will contain the green component if not NULL + * @param out_b will contain the blue component if not NULL + * @param out_a will contain the alpha component if not NULL + */ + static void FromInt(uint32_t color, float *out_r, float *out_g, float *out_b, float *out_a); + + /** + * Converts a 32-bit hex representation of a color to a color object. + * @param color the 32-bit hex color value to convert + * @return an equivalent color object + */ + static Color FromInt(uint32_t color); + + /** + * Packs RGBA color components into a 32-bit hex representation. + * @param r the red component (0-255) + * @param g the green component (0-255) + * @param b the blue component (0-255) + * @param a the alpha component (0-255) + * @return an equivalent 32-bit hex representation + */ + static uint32_t ToInt(uint8_t r, uint8_t g, uint8_t b, uint8_t a = COLOR_ALPHA_OPAQUE_INT); + + /** + * Packs RGBA color components into a 32-bit hex representation. + * @param r the red component + * @param g the green component + * @param b the blue component + * @param a the alpha component + * @return an equivalent 32-bit hex representation + */ + static uint32_t ToInt(float r, float g, float b, float a = COLOR_ALPHA_OPAQUE); + + float r; + float g; + float b; + float a; +}; + +#define COLOR_WHITE Color(1.0f, 1.0f, 1.0f) +#define COLOR_RED Color(1.0f, 0.0f, 0.0f) +#define COLOR_GREEN Color(0.0f, 1.0f, 0.0f) +#define COLOR_BLUE Color(0.0f, 0.0f, 1.0f) +#define COLOR_YELLOW Color(1.0f, 1.0f, 0.0f) +#define COLOR_CYAN Color(0.0f, 1.0f, 1.0f) +#define COLOR_MAGENTA Color(1.0f, 0.0f, 1.0f) +#define COLOR_BLACK Color(0.0f, 0.0f, 0.0f) + +inline Color::Color() +{ + r = 0.0f; + g = 0.0f; + b = 0.0f; + a = COLOR_ALPHA_OPAQUE; +} + +inline Color::Color(float red, float green, float blue, float alpha) +{ + r = red; + g = green; + b = blue; + a = alpha; +} + +inline Color::Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) +{ + uint32_t color = ToInt(red, green, blue, alpha); + FromInt(color, &r, &g, &b, &a); +} + +inline uint32_t Color::ToInt() const +{ + return ((uint32_t)(a * 255) << 24) | ((uint32_t)(r * 255) << 16) | ((uint32_t)(g * 255) << 8) | (uint32_t)(b * 255); +} + +inline void Color::ToInts(uint8_t *out_r, uint8_t *out_g, uint8_t *out_b, uint8_t *out_a) const +{ + if (out_r) + *out_r = (int)(r * 255); + if (out_g) + *out_g = (int)(g * 255); + if (out_b) + *out_b = (int)(b * 255); + if (out_a) + *out_a = (int)(a * 255); +} + +inline void Color::FromInt(uint32_t color, uint8_t *out_r, uint8_t *out_g, uint8_t *out_b, uint8_t *out_a) +{ + if (out_a) + *out_a = (color & 0xff000000) >> 24; + if (out_r) + *out_r = (color & 0x00ff0000) >> 16; + if (out_g) + *out_g = (color & 0x0000ff00) >> 8; + if (out_b) + *out_b = (color & 0x000000ff); +} + +inline void Color::FromInt(uint32_t color, float *out_r, float *out_g, float *out_b, float *out_a) +{ + if (out_a) + *out_a = ((float)((color & 0xff000000) >> 24)) / 255; + if (out_r) + *out_r = ((float)((color & 0x00ff0000) >> 16)) / 255; + if (out_g) + *out_g = ((float)((color & 0x0000ff00) >> 8)) / 255; + if (out_b) + *out_b = ((float)((color & 0x000000ff))) / 255; +} + +inline Color Color::FromInt(uint32_t color) +{ + Color out; + FromInt(color, &out.r, &out.g, &out.b, &out.a); + return out; +} + +inline uint32_t Color::ToInt(uint8_t r, uint8_t g, uint8_t b, uint8_t a) +{ + return (a << 24) | (r << 16) | (g << 8) | b; +} + +inline uint32_t Color::ToInt(float r, float g, float b, float a) +{ + return ((int)(a * 255) << 24) | ((int)(r * 255) << 16) | ((int)(g * 255) << 8) | (int)(b * 255); +} + +#endif + diff --git a/src/framework/graphics/customspriteshader.cpp b/src/framework/graphics/customspriteshader.cpp new file mode 100644 index 0000000..3784574 --- /dev/null +++ b/src/framework/graphics/customspriteshader.cpp @@ -0,0 +1,45 @@ +#include "../debug.h" + +#include "customspriteshader.h" +#include "../support/text.h" + +CustomSpriteShader::CustomSpriteShader(const char *vertexShaderSource, const char *fragmentShaderSource) + : SpriteShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + BOOL result = LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource, fragmentShaderSource); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetTextureHasAlphaOnlyUniform()) == TRUE); +} + +CustomSpriteShader::CustomSpriteShader(const Text *vertexShaderSource, const Text *fragmentShaderSource) + : SpriteShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(vertexShaderSource->GetLength() > 0); + ASSERT(fragmentShaderSource != NULL); + ASSERT(fragmentShaderSource->GetLength() > 0); + + BOOL result = LoadCompileAndLink(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetTextureHasAlphaOnlyUniform()) == TRUE); +} + +CustomSpriteShader::~CustomSpriteShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/customspriteshader.h b/src/framework/graphics/customspriteshader.h new file mode 100644 index 0000000..9bb83df --- /dev/null +++ b/src/framework/graphics/customspriteshader.h @@ -0,0 +1,34 @@ +#ifndef __FRAMEWORK_GRAPHICS_CUSTOMSPRITESHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_CUSTOMSPRITESHADER_H_INCLUDED__ + +#include "spriteshader.h" + +class Text; + +/** + * Shader class for rendering 2D or 3D (via billboards) sprites using custom + * GLSL sources. + */ +class CustomSpriteShader : public SpriteShader +{ +public: + /** + * Creates a new shader object for rendering sprites using the given vertex + * and fragment shader sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + CustomSpriteShader(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Creates a new shader object for rendering sprites using the given vertex + * and fragment shader sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + CustomSpriteShader(const Text *vertexShaderSource, const Text *fragmentShaderSource); + + virtual ~CustomSpriteShader(); +}; + +#endif diff --git a/src/framework/graphics/customstandardshader.cpp b/src/framework/graphics/customstandardshader.cpp new file mode 100644 index 0000000..1c7ead1 --- /dev/null +++ b/src/framework/graphics/customstandardshader.cpp @@ -0,0 +1,43 @@ +#include "../debug.h" + +#include "customstandardshader.h" +#include "../support/text.h" + +CustomStandardShader::CustomStandardShader(const char *vertexShaderSource, const char *fragmentShaderSource) + : StandardShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + BOOL result = LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource, fragmentShaderSource); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); +} + +CustomStandardShader::CustomStandardShader(const Text *vertexShaderSource, const Text *fragmentShaderSource) + : StandardShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(vertexShaderSource->GetLength() > 0); + ASSERT(fragmentShaderSource != NULL); + ASSERT(fragmentShaderSource->GetLength() > 0); + + BOOL result = LoadCompileAndLink(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); +} + +CustomStandardShader::~CustomStandardShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/customstandardshader.h b/src/framework/graphics/customstandardshader.h new file mode 100644 index 0000000..7973935 --- /dev/null +++ b/src/framework/graphics/customstandardshader.h @@ -0,0 +1,33 @@ +#ifndef __FRAMEWORK_GRAPHICS_CUSTOMSTANDARDSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_CUSTOMSTANDARDSHADER_H_INCLUDED__ + +#include "standardshader.h" + +class Text; + +/** + * Generic shader class providing standard uniforms for convenience. + */ +class CustomStandardShader : public StandardShader +{ +public: + /** + * Creates a new shader object using the given vertex and fragment shader + * sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + CustomStandardShader(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Creates a new shader object using the given vertex and fragment shader + * sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + CustomStandardShader(const Text *vertexShaderSource, const Text *fragmentShaderSource); + + virtual ~CustomStandardShader(); +}; + +#endif diff --git a/src/framework/graphics/customtextureatlas.cpp b/src/framework/graphics/customtextureatlas.cpp new file mode 100644 index 0000000..7e737ca --- /dev/null +++ b/src/framework/graphics/customtextureatlas.cpp @@ -0,0 +1,66 @@ +#include "../debug.h" + +#include "customtextureatlas.h" + +#include "texture.h" +#include "../math/rect.h" + +CustomTextureAtlas::CustomTextureAtlas(uint16_t textureWidth, uint16_t textureHeight, float texCoordEdgeOffset) + : TextureAtlas(textureWidth, textureHeight, texCoordEdgeOffset) +{ + STACK_TRACE; +} + +CustomTextureAtlas::CustomTextureAtlas(Texture *source, float texCoordEdgeOffset) + : TextureAtlas(source, texCoordEdgeOffset) +{ + STACK_TRACE; +} + +CustomTextureAtlas::~CustomTextureAtlas() +{ + STACK_TRACE; +} + +uint32_t CustomTextureAtlas::Add(const Rect &position) +{ + STACK_TRACE; + return Add(position.left, position.top, position.right, position.bottom); +} + +uint32_t CustomTextureAtlas::Add(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) +{ + STACK_TRACE; + ASSERT(right <= GetWidth()); + ASSERT(bottom <= GetHeight()); + ASSERT(left < right); + ASSERT(top < bottom); + + TextureAtlasTile tile; + + // set pixel location/dimensions + tile.dimensions.left = left; + tile.dimensions.top = top; + tile.dimensions.right = right; + tile.dimensions.bottom = bottom; + + // set texture coordinates + // HACK: subtract GetTexCoordEdgeOffset() from the bottom right edges to + // get around floating point rounding errors (adjacent tiles will + // slightly bleed in otherwise) + tile.texCoords.left = ((float)left + GetTexCoordEdgeOffset()) / (float)GetWidth(); + tile.texCoords.top = ((float)top + GetTexCoordEdgeOffset()) / (float)GetHeight(); + tile.texCoords.right = ((float)right - GetTexCoordEdgeOffset()) / (float)GetWidth(); + tile.texCoords.bottom = ((float)bottom - GetTexCoordEdgeOffset()) / (float)GetHeight(); + + m_tiles.push_back(tile); + + // index we just added + return m_tiles.size() - 1; +} + +void CustomTextureAtlas::Reset() +{ + STACK_TRACE; + m_tiles.clear(); +} diff --git a/src/framework/graphics/customtextureatlas.h b/src/framework/graphics/customtextureatlas.h new file mode 100644 index 0000000..04f49b3 --- /dev/null +++ b/src/framework/graphics/customtextureatlas.h @@ -0,0 +1,62 @@ +#ifndef __FRAMEWORK_GRAPHICS_CUSTOMTEXTUREATLAS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_CUSTOMTEXTUREATLAS_H_INCLUDED__ + +#include "../common.h" +#include "textureatlas.h" + +class Texture; +struct Rect; + +/** + * Texture atlas manager allowing arbitrary sub-textures to be defined. + */ +class CustomTextureAtlas : public TextureAtlas +{ +public: + /** + * Creates a texture atlas object with the specified properties. + * @param textureWidth the width in pixels of the texture that will + * be used for this atlas + * @param textureHeight the height in pixels of the texture that + * will be used for this atlas + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + CustomTextureAtlas(uint16_t textureWidth, uint16_t textureHeight, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + /** + * Creates a texture atlas object with the specified properties. + * @param source the underlying texture to use for this atlas + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + CustomTextureAtlas(Texture *source, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + virtual ~CustomTextureAtlas(); + + /** + * Adds a new definition for a sub-texture / tile. + * @param position the pixel coordinates of the sub-texture / tile + * @return the index of the new definition + */ + uint32_t Add(const Rect &position); + + /** + * Adds a new definition for a sub-texture / tile. + * @param left left X coordinate of the sub-texture / tile + * @param top top Y coordinate of the sub-texture / tile + * @param right right X coordinate of the sub-texture / tile + * @param bottom bottom Y coordinate of the sub-texture / tile + * @return the index of the new definition + */ + uint32_t Add(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom); + + /** + * Clears all sub-texture / tile definitions. + */ + void Reset(); +}; + +#endif diff --git a/src/framework/graphics/customvertexlerpshader.cpp b/src/framework/graphics/customvertexlerpshader.cpp new file mode 100644 index 0000000..9d3b67f --- /dev/null +++ b/src/framework/graphics/customvertexlerpshader.cpp @@ -0,0 +1,45 @@ +#include "../debug.h" + +#include "customvertexlerpshader.h" +#include "../support/text.h" + +CustomVertexLerpShader::CustomVertexLerpShader(const char *vertexShaderSource, const char *fragmentShaderSource) + : VertexLerpShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + BOOL result = LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource, fragmentShaderSource); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetLerpUniform()) == TRUE); +} + +CustomVertexLerpShader::CustomVertexLerpShader(const Text *vertexShaderSource, const Text *fragmentShaderSource) + : VertexLerpShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(vertexShaderSource->GetLength() > 0); + ASSERT(fragmentShaderSource != NULL); + ASSERT(fragmentShaderSource->GetLength() > 0); + + BOOL result = LoadCompileAndLink(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetLerpUniform()) == TRUE); +} + +CustomVertexLerpShader::~CustomVertexLerpShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/customvertexlerpshader.h b/src/framework/graphics/customvertexlerpshader.h new file mode 100644 index 0000000..002b906 --- /dev/null +++ b/src/framework/graphics/customvertexlerpshader.h @@ -0,0 +1,18 @@ +#ifndef __FRAMEWORK_GRAPHICS_CUSTOMVERTEXLERPSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_CUSTOMVERTEXLERPSHADER_H_INCLUDED__ + +#include "vertexlerpshader.h" + +class Text; + +class CustomVertexLerpShader : public VertexLerpShader +{ +public: + CustomVertexLerpShader(const char *vertexShaderSource, const char *fragmentShaderSource); + + CustomVertexLerpShader(const Text *vertexShaderSource, const Text *fragmentShaderSource); + + virtual ~CustomVertexLerpShader(); +}; + +#endif diff --git a/src/framework/graphics/customvertexskinningshader.cpp b/src/framework/graphics/customvertexskinningshader.cpp new file mode 100644 index 0000000..3b10715 --- /dev/null +++ b/src/framework/graphics/customvertexskinningshader.cpp @@ -0,0 +1,47 @@ +#include "../debug.h" + +#include "customvertexskinningshader.h" +#include "../support/text.h" + +CustomVertexSkinningShader::CustomVertexSkinningShader(const char *vertexShaderSource, const char *fragmentShaderSource) + : VertexSkinningShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + BOOL result = LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource, fragmentShaderSource); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetJointPositionsUniform()) == TRUE); + ASSERT(HasUniform(GetJointRotationsUniform()) == TRUE); +} + +CustomVertexSkinningShader::CustomVertexSkinningShader(const Text *vertexShaderSource, const Text *fragmentShaderSource) + : VertexSkinningShader() +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(vertexShaderSource->GetLength() > 0); + ASSERT(fragmentShaderSource != NULL); + ASSERT(fragmentShaderSource->GetLength() > 0); + + BOOL result = LoadCompileAndLink(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + ASSERT(result == TRUE); + + CacheShaderSources(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + + ASSERT(HasUniform(GetModelViewMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetProjectionMatrixUniform()) == TRUE); + ASSERT(HasUniform(GetJointPositionsUniform()) == TRUE); + ASSERT(HasUniform(GetJointRotationsUniform()) == TRUE); +} + +CustomVertexSkinningShader::~CustomVertexSkinningShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/customvertexskinningshader.h b/src/framework/graphics/customvertexskinningshader.h new file mode 100644 index 0000000..0a27aa8 --- /dev/null +++ b/src/framework/graphics/customvertexskinningshader.h @@ -0,0 +1,18 @@ +#ifndef __FRAMEWORK_GRAPHICS_CUSTOMVERTEXSKINNINGSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_CUSTOMVERTEXSKINNINGSHADER_H_INCLUDED__ + +#include "vertexskinningshader.h" + +class Text; + +class CustomVertexSkinningShader : public VertexSkinningShader +{ +public: + CustomVertexSkinningShader(const char *vertexShaderSource, const char *fragmentShaderSource); + + CustomVertexSkinningShader(const Text *vertexShaderSource, const Text *fragmentShaderSource); + + virtual ~CustomVertexSkinningShader(); +}; + +#endif diff --git a/src/framework/graphics/debugshader.cpp b/src/framework/graphics/debugshader.cpp new file mode 100644 index 0000000..cbd1a53 --- /dev/null +++ b/src/framework/graphics/debugshader.cpp @@ -0,0 +1,47 @@ +#include "../debug.h" + +#include "debugshader.h" + +const char* DebugShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec4 a_color;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "\n" + "void main()\n" + "{\n" + " v_color = a_color;\n" + " gl_PointSize = 4.0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* DebugShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " #define LOWP lowp\n" + " precision mediump float;\n" + "#else\n" + " #define LOWP\n" + "#endif\n" + "varying LOWP vec4 v_color;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = v_color;\n" + "}\n"; + +DebugShader::DebugShader() + : StandardShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_color", VERTEX_COLOR); +} + +DebugShader::~DebugShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/debugshader.h b/src/framework/graphics/debugshader.h new file mode 100644 index 0000000..8c27f71 --- /dev/null +++ b/src/framework/graphics/debugshader.h @@ -0,0 +1,21 @@ +#ifndef __FRAMEWORK_GRAPHICS_DEBUGSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_DEBUGSHADER_H_INCLUDED__ + +#include "standardshader.h" + +/** + * Shader for rendering debug geometry. Will render using solid colors + * with thicker lines and larger point sizes. + */ +class DebugShader : public StandardShader +{ +public: + DebugShader(); + virtual ~DebugShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/framebuffer.cpp b/src/framework/graphics/framebuffer.cpp new file mode 100644 index 0000000..5e4aaa0 --- /dev/null +++ b/src/framework/graphics/framebuffer.cpp @@ -0,0 +1,660 @@ +#include "../debug.h" + +#include "../common.h" +#include "framebuffer.h" +#include "framebufferdatatypes.h" +#include "glincludes.h" +#include "glutils.h" +#include "graphicsdevice.h" +#include "renderbuffer.h" +#include "texture.h" +#include "viewcontext.h" +#include "../gamewindow.h" +#include "../math/rect.h" +#include + +Framebuffer::Framebuffer() +{ + STACK_TRACE; + m_graphicsDevice = NULL; + m_viewContext = NULL; + m_framebufferName = 0; + m_fixedWidth = 0; + m_fixedHeight = 0; +} + +Framebuffer::~Framebuffer() +{ + STACK_TRACE; + Release(); +} + +BOOL Framebuffer::Create(GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + ASSERT(graphicsDevice != NULL); + ASSERT(m_framebufferName == 0); + if (m_framebufferName != 0) + return FALSE; + + GL_CALL(glGenFramebuffers(1, &m_framebufferName)); + + m_graphicsDevice = graphicsDevice; + m_viewContext = NULL; + m_fixedWidth = 0; + m_fixedHeight = 0; + + return TRUE; +} + +BOOL Framebuffer::Create(GraphicsDevice *graphicsDevice, uint16_t fixedWidth, uint16_t fixedHeight) +{ + STACK_TRACE; + ASSERT(fixedWidth != 0); + ASSERT(fixedHeight != 0); + if (fixedWidth == 0 || fixedHeight == 0) + return FALSE; + + BOOL createSuccess = Create(graphicsDevice); + if (!createSuccess) + return FALSE; + + m_fixedWidth = fixedWidth; + m_fixedHeight = fixedHeight; + + return TRUE; +} + +void Framebuffer::Release() +{ + STACK_TRACE; + if (m_framebufferName != 0) + { + for (FramebufferRenderbufferMap::iterator i = m_renderbuffers.begin(); i != m_renderbuffers.end(); ++i) + { + Renderbuffer *renderbuffer = i->second; + SAFE_DELETE(renderbuffer); + } + m_renderbuffers.clear(); + + for (FramebufferTextureMap::iterator i = m_textures.begin(); i != m_textures.end(); ++i) + { + Texture *texture = i->second; + SAFE_DELETE(texture); + } + m_textures.clear(); + + GL_CALL(glDeleteFramebuffers(1, &m_framebufferName)); + } + + if (m_graphicsDevice != NULL) + { + if (m_graphicsDevice->GetViewContext() == m_viewContext) + m_graphicsDevice->SetViewContext(NULL); + + SAFE_DELETE(m_viewContext); + } + + m_framebufferName = 0; + m_graphicsDevice = NULL; + m_fixedWidth = 0; + m_fixedHeight = 0; +} + +BOOL Framebuffer::AttachViewContext() +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + ASSERT(m_viewContext == NULL); + if (m_viewContext != NULL) + return FALSE; + + m_viewContext = new ViewContext(); + BOOL success; + if (IsUsingFixedDimensions()) + success = m_viewContext->Create(m_graphicsDevice, Rect(0, 0, m_fixedWidth, m_fixedHeight)); + else + success = m_viewContext->Create(m_graphicsDevice); + if (!success) + { + SAFE_DELETE(m_viewContext); + return FALSE; + } + + return TRUE; +} + +BOOL Framebuffer::AttachTexture(FRAMEBUFFER_DATA_TYPE type) +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Texture *existing = GetTexture(type); + ASSERT(existing == NULL); + if (existing != NULL) + return FALSE; + + // also need to make sure a renderbuffer isn't already attached to this type! + Renderbuffer *existingRenderbuffer = GetRenderbuffer(type); + ASSERT(existingRenderbuffer == NULL); + if (existingRenderbuffer != NULL) + return FALSE; + + // don't allow unsupported types! + if (type == FRAMEBUFFER_DATA_NONE) + return FALSE; + if (type == FRAMEBUFFER_DATA_DEPTH && !m_graphicsDevice->IsDepthTextureSupported()) + return FALSE; + if (type == FRAMEBUFFER_DATA_STENCIL) + return FALSE; + + // determine texture format and framebuffer attachment type + TEXTURE_FORMAT textureFormat; + GLenum attachmentType; + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + textureFormat = TEXTURE_FORMAT_RGB; + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_COLOR_RGBA: + textureFormat = TEXTURE_FORMAT_RGBA; + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_DEPTH: + textureFormat = TEXTURE_FORMAT_DEPTH; + attachmentType = GL_DEPTH_ATTACHMENT; + break; + default: + textureFormat = TEXTURE_FORMAT_NONE; + attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + uint16_t width = 0; + uint16_t height = 0; + GetDimensionsForAttachment(width, height); + + Texture *attach = new Texture(); + BOOL textureSuccess = attach->Create(m_graphicsDevice, width, height, textureFormat); + ASSERT(textureSuccess == TRUE); + if (!textureSuccess) + { + SAFE_DELETE(attach); + return FALSE; + } + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, attachmentType, GL_TEXTURE_2D, attach->GetTextureName(), 0)); + m_graphicsDevice->UnbindFramebuffer(this); + + m_textures[type] = attach; + + return TRUE; +} + +BOOL Framebuffer::ReCreateAndAttach(FramebufferTextureMap::iterator &itor, BOOL releaseFirst) +{ + STACK_TRACE; + Texture *existing = itor->second; + + // determine attachment type + GLenum attachmentType; + switch (existing->GetFormat()) + { + case TEXTURE_FORMAT_RGB: + case TEXTURE_FORMAT_RGBA: attachmentType = GL_COLOR_ATTACHMENT0; break; + case TEXTURE_FORMAT_DEPTH: attachmentType = GL_DEPTH_ATTACHMENT; break; + default: attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + uint16_t width = 0; + uint16_t height = 0; + GetDimensionsForAttachment(width, height); + + TEXTURE_FORMAT existingFormat = existing->GetFormat(); + + if (releaseFirst) + existing->Release(); + + BOOL textureSuccess = existing->Create(m_graphicsDevice, width, height, existingFormat); + ASSERT(textureSuccess == TRUE); + if (!textureSuccess) + return FALSE; + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, attachmentType, GL_TEXTURE_2D, existing->GetTextureName(), 0)); + m_graphicsDevice->UnbindFramebuffer(this); + + return TRUE; +} + +BOOL Framebuffer::AttachRenderbuffer(FRAMEBUFFER_DATA_TYPE type) +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Renderbuffer *existing = GetRenderbuffer(type); + ASSERT(existing == NULL); + if (existing != NULL) + return FALSE; + + // also need to make sure a texture isn't already attached to this type! + Texture *existingTexture = GetTexture(type); + ASSERT(existingTexture == NULL); + if (existingTexture != NULL) + return FALSE; + + // don't allow unsupported types! + if (type == FRAMEBUFFER_DATA_NONE) + return FALSE; + + // determine framebuffer attachment type + GLenum attachmentType; + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + case FRAMEBUFFER_DATA_COLOR_RGBA: attachmentType = GL_COLOR_ATTACHMENT0; break; + case FRAMEBUFFER_DATA_DEPTH: attachmentType = GL_DEPTH_ATTACHMENT; break; + case FRAMEBUFFER_DATA_STENCIL: attachmentType = GL_STENCIL_ATTACHMENT; break; + default: attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + uint16_t width = 0; + uint16_t height = 0; + GetDimensionsForAttachment(width, height); + + Renderbuffer *attach = new Renderbuffer(); + BOOL renderbufferSuccess = attach->Create(m_graphicsDevice, width, height, type); + ASSERT(renderbufferSuccess == TRUE); + if (!renderbufferSuccess) + { + SAFE_DELETE(attach); + return FALSE; + } + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachmentType, GL_RENDERBUFFER, attach->GetRenderbufferName())); + m_graphicsDevice->UnbindFramebuffer(this); + + m_renderbuffers[type] = attach; + + return TRUE; +} + +BOOL Framebuffer::ReCreateAndAttach(FramebufferRenderbufferMap::iterator &itor, BOOL releaseFirst) +{ + STACK_TRACE; + Renderbuffer *existing = itor->second; + + // determine framebuffer attachment type + GLenum attachmentType; + switch (existing->GetType()) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + case FRAMEBUFFER_DATA_COLOR_RGBA: attachmentType = GL_COLOR_ATTACHMENT0; break; + case FRAMEBUFFER_DATA_DEPTH: attachmentType = GL_DEPTH_ATTACHMENT; break; + case FRAMEBUFFER_DATA_STENCIL: attachmentType = GL_STENCIL_ATTACHMENT; break; + default: attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + uint16_t width = 0; + uint16_t height = 0; + GetDimensionsForAttachment(width, height); + + FRAMEBUFFER_DATA_TYPE existingType = existing->GetType(); + + if (releaseFirst) + existing->Release(); + + BOOL renderbufferSuccess = existing->Create(m_graphicsDevice, width, height, existingType); + ASSERT(renderbufferSuccess == TRUE); + if (!renderbufferSuccess) + return FALSE; + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachmentType, GL_RENDERBUFFER, existing->GetRenderbufferName())); + m_graphicsDevice->UnbindFramebuffer(this); + + return TRUE; +} + +BOOL Framebuffer::ReleaseViewContext() +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + ASSERT(m_viewContext != NULL); + if (m_viewContext == NULL) + return FALSE; + + if (m_graphicsDevice->GetViewContext() == m_viewContext) + m_graphicsDevice->SetViewContext(NULL); + + SAFE_DELETE(m_viewContext); + + return TRUE; +} + +BOOL Framebuffer::ReleaseTexture(FRAMEBUFFER_DATA_TYPE type) +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Texture *existing = GetTexture(type); + ASSERT(existing != NULL); + if (existing == NULL) + return FALSE; + + // determine attachment type + GLenum attachmentType; + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_COLOR_RGBA: + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_DEPTH: + attachmentType = GL_DEPTH_ATTACHMENT; + break; + default: + attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, attachmentType, GL_TEXTURE_2D, 0, 0)); + m_graphicsDevice->UnbindFramebuffer(this); + + BOOL removeSuccess = RemoveTexture(existing); + ASSERT(removeSuccess == TRUE); + if (!removeSuccess) + return FALSE; + + return TRUE; +} + +BOOL Framebuffer::ReleaseRenderbuffer(FRAMEBUFFER_DATA_TYPE type) +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Renderbuffer *existing = GetRenderbuffer(type); + ASSERT(existing != NULL); + if (existing == NULL) + return FALSE; + + // determine attachment type + GLenum attachmentType; + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_COLOR_RGBA: + attachmentType = GL_COLOR_ATTACHMENT0; + break; + case FRAMEBUFFER_DATA_DEPTH: + attachmentType = GL_DEPTH_ATTACHMENT; + break; + default: + attachmentType = 0; + } + ASSERT(attachmentType != 0); + if (attachmentType == 0) + return FALSE; + + m_graphicsDevice->BindFramebuffer(this); + GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachmentType, GL_RENDERBUFFER, 0)); + m_graphicsDevice->UnbindFramebuffer(this); + + BOOL removeSuccess = RemoveRenderbuffer(existing); + ASSERT(removeSuccess == TRUE); + if (!removeSuccess) + return FALSE; + + return TRUE; +} + +Texture* Framebuffer::GetTexture(FRAMEBUFFER_DATA_TYPE type) const +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Texture *result = NULL; + + FramebufferTextureMap::const_iterator i = m_textures.find(type); + + // color could be RGB or RGBA -- can't have both! so one needs to match + // the other if present! + if (i == m_textures.end() && (type == FRAMEBUFFER_DATA_COLOR_RGB || FRAMEBUFFER_DATA_COLOR_RGBA)) + { + FRAMEBUFFER_DATA_TYPE otherColorType = (type == FRAMEBUFFER_DATA_COLOR_RGB ? FRAMEBUFFER_DATA_COLOR_RGBA : FRAMEBUFFER_DATA_COLOR_RGB); + i = m_textures.find(otherColorType); + } + + // *now* we can test if found or not + if (i != m_textures.end()) + result = i->second; + + return result; +} + +Renderbuffer* Framebuffer::GetRenderbuffer(FRAMEBUFFER_DATA_TYPE type) const +{ + STACK_TRACE; + ASSERT(m_framebufferName != 0); + if (m_framebufferName == 0) + return FALSE; + + Renderbuffer *result = NULL; + + FramebufferRenderbufferMap::const_iterator i = m_renderbuffers.find(type); + + // color could be RGB or RGBA -- can't have both! so one needs to match + // the other if present! + if (i == m_renderbuffers.end() && (type == FRAMEBUFFER_DATA_COLOR_RGB || FRAMEBUFFER_DATA_COLOR_RGBA)) + { + FRAMEBUFFER_DATA_TYPE otherColorType = (type == FRAMEBUFFER_DATA_COLOR_RGB ? FRAMEBUFFER_DATA_COLOR_RGBA : FRAMEBUFFER_DATA_COLOR_RGB); + i = m_renderbuffers.find(otherColorType); + } + + // *now* we can test if found or not + if (i != m_renderbuffers.end()) + result = i->second; + + return result; +} + +void Framebuffer::OnNewContext() +{ + STACK_TRACE; + if (m_framebufferName == 0 && m_graphicsDevice != NULL) + { + // the view context (if one is set) doesn't need to be recreated + // but the call to Create() will reset the pointer + // TODO: maybe this should call a Recreate() method instead + ViewContext *viewContext = m_viewContext; + + // recreate the framebuffer + BOOL createSuccess = Create(m_graphicsDevice); + ASSERT(createSuccess == TRUE); + if (!createSuccess) + { + m_framebufferName = 0; + m_viewContext = viewContext; + return; + } + + m_viewContext = viewContext; + if (m_viewContext != NULL) + m_viewContext->OnNewContext(); + + // now recreate & reattach all the attachment points that were set + + for (FramebufferTextureMap::iterator i = m_textures.begin(); i != m_textures.end(); ++i) + { + BOOL success = ReCreateAndAttach(i, FALSE); + ASSERT(success == TRUE); + if (!success) + { + Release(); + return; + } + } + + for (FramebufferRenderbufferMap::iterator i = m_renderbuffers.begin(); i != m_renderbuffers.end(); ++i) + { + BOOL success = ReCreateAndAttach(i, FALSE); + ASSERT(success == TRUE); + if (!success) + { + Release(); + return; + } + } + } +} + +void Framebuffer::OnLostContext() +{ + STACK_TRACE; + m_framebufferName = 0; + if (m_viewContext != NULL) + m_viewContext->OnLostContext(); + for (FramebufferTextureMap::iterator i = m_textures.begin(); i != m_textures.end(); ++i) + i->second->OnLostContext(); + for (FramebufferRenderbufferMap::iterator i = m_renderbuffers.begin(); i != m_renderbuffers.end(); ++i) + i->second->OnLostContext(); +} + +void Framebuffer::OnResize() +{ + STACK_TRACE; + if (m_framebufferName != 0 && m_graphicsDevice != NULL) + { + if (m_viewContext != NULL) + { + GameWindow *window = m_graphicsDevice->GetWindow(); + m_viewContext->OnResize(window->GetRect(), window->GetScreenOrientation()); + } + + // now recreate & reattach all the attachment points that were set + + for (FramebufferTextureMap::iterator i = m_textures.begin(); i != m_textures.end(); ++i) + { + BOOL success = ReCreateAndAttach(i, TRUE); + ASSERT(success == TRUE); + if (!success) + { + Release(); + return; + } + } + + for (FramebufferRenderbufferMap::iterator i = m_renderbuffers.begin(); i != m_renderbuffers.end(); ++i) + { + BOOL success = ReCreateAndAttach(i, TRUE); + ASSERT(success == TRUE); + if (!success) + { + Release(); + return; + } + } + } +} + +void Framebuffer::OnBind() +{ + STACK_TRACE; +} + +void Framebuffer::OnUnBind() +{ + STACK_TRACE; +} + +BOOL Framebuffer::RemoveTexture(Texture *texture) +{ + STACK_TRACE; + for (FramebufferTextureMap::iterator i = m_textures.begin(); i != m_textures.end(); ++i) + { + if (i->second == texture) + { + SAFE_DELETE(texture); + m_textures.erase(i); + return TRUE; + } + } + + return FALSE; +} + +BOOL Framebuffer::RemoveRenderbuffer(Renderbuffer *renderbuffer) +{ + STACK_TRACE; + for (FramebufferRenderbufferMap::iterator i = m_renderbuffers.begin(); i != m_renderbuffers.end(); ++i) + { + if (i->second == renderbuffer) + { + SAFE_DELETE(renderbuffer); + m_renderbuffers.erase(i); + return TRUE; + } + } + + return FALSE; +} + +void Framebuffer::GetDimensionsForAttachment(uint16_t &width, uint16_t &height) const +{ + STACK_TRACE; + if (IsUsingFixedDimensions()) + { + width = m_fixedWidth; + height = m_fixedHeight; + } + else + { + const ViewContext *viewContext = NULL; + if (m_viewContext != NULL) + viewContext = m_viewContext; + else + viewContext = m_graphicsDevice->GetViewContext(); + + ASSERT(viewContext != NULL); + width = viewContext->GetViewportWidth(); + height = viewContext->GetViewportHeight(); + } +} diff --git a/src/framework/graphics/framebuffer.h b/src/framework/graphics/framebuffer.h new file mode 100644 index 0000000..27c250a --- /dev/null +++ b/src/framework/graphics/framebuffer.h @@ -0,0 +1,68 @@ +#ifndef __FRAMEWORK_GRAPHICS_FRAMEBUFFER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_FRAMEBUFFER_H_INCLUDED__ + +#include "../common.h" +#include "framebufferdatatypes.h" +#include "graphicscontextresource.h" +#include + +class GraphicsDevice; +class Renderbuffer; +class Texture; +class ViewContext; + +typedef stl::map FramebufferRenderbufferMap; +typedef stl::map FramebufferTextureMap; + +class Framebuffer : public GraphicsContextResource +{ + friend class GraphicsDevice; + +public: + Framebuffer(); + virtual ~Framebuffer(); + + BOOL Create(GraphicsDevice *graphicsDevice); + BOOL Create(GraphicsDevice *graphicsDevice, uint16_t fixedWidth, uint16_t fixedHeight); + void Release(); + + uint32_t GetFramebufferName() const { return m_framebufferName; } + BOOL IsInvalidated() const { return m_framebufferName == 0; } + BOOL IsUsingFixedDimensions() const { return (m_fixedWidth != 0 && m_fixedHeight != 0); } + + BOOL AttachViewContext(); + BOOL AttachTexture(FRAMEBUFFER_DATA_TYPE type); + BOOL AttachRenderbuffer(FRAMEBUFFER_DATA_TYPE type); + BOOL ReleaseViewContext(); + BOOL ReleaseTexture(FRAMEBUFFER_DATA_TYPE type); + BOOL ReleaseRenderbuffer(FRAMEBUFFER_DATA_TYPE type); + + ViewContext* GetViewContext() const { return m_viewContext; } + Texture* GetTexture(FRAMEBUFFER_DATA_TYPE type) const; + Renderbuffer* GetRenderbuffer(FRAMEBUFFER_DATA_TYPE type) const; + + void OnNewContext(); + void OnLostContext(); + void OnResize(); + +private: + void OnBind(); + void OnUnBind(); + + BOOL ReCreateAndAttach(FramebufferTextureMap::iterator &itor, BOOL releaseFirst); + BOOL ReCreateAndAttach(FramebufferRenderbufferMap::iterator &itor, BOOL releaseFirst); + BOOL RemoveTexture(Texture *texture); + BOOL RemoveRenderbuffer(Renderbuffer *renderbuffer); + + void GetDimensionsForAttachment(uint16_t &width, uint16_t &height) const; + + uint32_t m_framebufferName; + GraphicsDevice *m_graphicsDevice; + uint16_t m_fixedWidth; + uint16_t m_fixedHeight; + ViewContext *m_viewContext; + FramebufferRenderbufferMap m_renderbuffers; + FramebufferTextureMap m_textures; +}; + +#endif diff --git a/src/framework/graphics/framebufferdatatypes.h b/src/framework/graphics/framebufferdatatypes.h new file mode 100644 index 0000000..d025cad --- /dev/null +++ b/src/framework/graphics/framebufferdatatypes.h @@ -0,0 +1,17 @@ +#ifndef __FRAMEWORK_GRAPHICS_FRAMEBUFFERDATATYPES_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_FRAMEBUFFERDATATYPES_H_INCLUDED__ + +/** + * Constant values used to refer to the type of data values that a + * framebuffer's texture/renderbuffer attachments contain. + */ +enum FRAMEBUFFER_DATA_TYPE +{ + FRAMEBUFFER_DATA_NONE = 0, + FRAMEBUFFER_DATA_COLOR_RGB = 1, + FRAMEBUFFER_DATA_COLOR_RGBA = 2, + FRAMEBUFFER_DATA_DEPTH = 3, + FRAMEBUFFER_DATA_STENCIL = 4 +}; + +#endif diff --git a/src/framework/graphics/geometrydebugrenderer.cpp b/src/framework/graphics/geometrydebugrenderer.cpp new file mode 100644 index 0000000..3462b58 --- /dev/null +++ b/src/framework/graphics/geometrydebugrenderer.cpp @@ -0,0 +1,258 @@ +#include "../debug.h" + +#include "geometrydebugrenderer.h" + +#include + +#include "graphicsdevice.h" +#include "debugshader.h" +#include "renderstate.h" +#include "vertexbuffer.h" +#include "viewcontext.h" +#include "../math/vector3.h" +#include "../math/boundingbox.h" +#include "../math/boundingsphere.h" +#include "../math/linesegment.h" +#include "../math/point3.h" +#include "../math/ray.h" + +GeometryDebugRenderer::GeometryDebugRenderer(GraphicsDevice *graphicsDevice, BOOL depthTesting) +{ + STACK_TRACE; + m_graphicsDevice = graphicsDevice; + m_color1 = Color(1.0f, 1.0f, 0.0f); + m_color2 = Color(1.0f, 0.0f, 0.0f); + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + m_renderState->SetDepthTesting(depthTesting); + m_renderState->SetLineWidth(2.0f); + + m_vertices = new VertexBuffer(BUFFEROBJECT_USAGE_STREAM); + ASSERT(m_vertices != NULL); + m_vertices->AddAttribute(VERTEX_POS_3D); + m_vertices->AddAttribute(VERTEX_COLOR); + m_vertices->Create(16384); + m_currentVertex = 0; + + m_begunRendering = FALSE; +} + +GeometryDebugRenderer::~GeometryDebugRenderer() +{ + STACK_TRACE; + SAFE_DELETE(m_vertices); + SAFE_DELETE(m_renderState); +} + +void GeometryDebugRenderer::Begin() +{ + STACK_TRACE; + m_currentVertex = 0; + m_begunRendering = TRUE; +} + +void GeometryDebugRenderer::Render(const BoundingBox &box, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + ASSERT(m_vertices->GetNumElements() > (m_currentVertex + 24)); + + uint32_t i = m_currentVertex; + + // removed lines which are duplicated by more then one face + // left and right faces don't need to be drawn at all (entirely duplicated lines) + + // top + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.min.z); + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.min.z); + + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.min.z); + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.max.z); + + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.max.z); + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.max.z); + + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.max.z); + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.min.z); + + // back + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.min.z); + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.min.z); + + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.min.z); + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.min.z); + + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.min.z); + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.min.z); + + // front + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.max.z); + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.max.z); + + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.max.z); + m_vertices->SetPosition3(i++, box.max.x, box.max.y, box.max.z); + + m_vertices->SetPosition3(i++, box.min.x, box.max.y, box.max.z); + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.max.z); + + // bottom + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.min.z); + m_vertices->SetPosition3(i++, box.max.x, box.min.y, box.max.z); + + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.max.z); + m_vertices->SetPosition3(i++, box.min.x, box.min.y, box.min.z); + + // fill in all the colours + for (uint32_t j = m_currentVertex; j < i; ++j) + m_vertices->SetColor(j, color); + + m_currentVertex = i; +} + +void GeometryDebugRenderer::Render(const Point3 &boxMin, const Point3 &boxMax, const Color &color) +{ + STACK_TRACE; + BoundingBox b((float)boxMin.x, (float)boxMin.y, (float)boxMin.z, (float)boxMax.x, (float)boxMax.y, (float)boxMax.z); + Render(b, color); +} + +void GeometryDebugRenderer::Render(const BoundingSphere &sphere, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + ASSERT(m_vertices->GetNumElements() > (m_currentVertex + 615)); + + uint32_t p = m_currentVertex; + + float ax, ay, az; + float bx, by, bz; + float cx = 0.0f, cy = 0.0f, cz = 0.0f; + float dx = 0.0f, dy = 0.0f, dz = 0.0f; + float theta1, theta2, theta3; + + int n = 12; + for (int j = 0; j < n / 2; ++j) + { + theta1 = j * PI * 2 / n - PI / 2; + theta2 = (j + 1) * PI * 2 / n - PI / 2; + + for (int i = 0; i <= n; ++i) + { + theta3 = i * PI * 2 / n; + ax = sphere.center.x + sphere.radius * cosf(theta2) * cosf(theta3); + ay = sphere.center.y + sphere.radius * sinf(theta2); + az = sphere.center.z + sphere.radius * cosf(theta2) * sinf(theta3); + + bx = sphere.center.x + sphere.radius * cosf(theta1) * cosf(theta3); + by = sphere.center.y + sphere.radius * sinf(theta1); + bz = sphere.center.z + sphere.radius * cosf(theta1) * sinf(theta3); + + if (j > 0 || i > 0) + { + m_vertices->SetPosition3(p++, ax, ay, az); + m_vertices->SetPosition3(p++, bx, by, bz); + + m_vertices->SetPosition3(p++, bx, by, bz); + m_vertices->SetPosition3(p++, dx, dy, dz); + + m_vertices->SetPosition3(p++, dx, dy, dz); + m_vertices->SetPosition3(p++, cx, cy, cz); + + m_vertices->SetPosition3(p++, cx, cy, cz); + m_vertices->SetPosition3(p++, ax, ay, az); + } + + cx = ax; + cy = ay; + cz = az; + dx = bx; + dy = by; + dz = bz; + } + } + + // fill in all the colours + for (uint32_t i = m_currentVertex; i < p; ++i) + m_vertices->SetColor(i, color); + + m_currentVertex = p; +} + +void GeometryDebugRenderer::Render(const Ray &ray, float length, const Color &color1, const Color &color2) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + ASSERT(m_vertices->GetNumElements() > (m_currentVertex + 2)); + + Vector3 temp = ray.GetPositionAt(length); + + m_vertices->SetPosition3(m_currentVertex, ray.position); + m_vertices->SetColor(m_currentVertex, color1); + m_vertices->SetPosition3(m_currentVertex + 1, temp); + m_vertices->SetColor(m_currentVertex + 1, color2); + + m_currentVertex += 2; +} + +void GeometryDebugRenderer::Render(const LineSegment &line, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + ASSERT(m_vertices->GetNumElements() > (m_currentVertex + 2)); + + m_vertices->SetPosition3(m_currentVertex, line.a); + m_vertices->SetColor(m_currentVertex, color); + m_vertices->SetPosition3(m_currentVertex + 1, line.b); + m_vertices->SetColor(m_currentVertex + 1, color); + + m_currentVertex += 2; +} + +void GeometryDebugRenderer::Render(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + ASSERT(m_vertices->GetNumElements() > (m_currentVertex + 6)); + + m_vertices->SetPosition3(m_currentVertex, a); + m_vertices->SetColor(m_currentVertex, color); + m_vertices->SetPosition3(m_currentVertex + 1, b); + m_vertices->SetColor(m_currentVertex + 1, color); + m_vertices->SetPosition3(m_currentVertex + 2, a); + m_vertices->SetColor(m_currentVertex + 2, color); + m_vertices->SetPosition3(m_currentVertex + 3, c); + m_vertices->SetColor(m_currentVertex + 3, color); + m_vertices->SetPosition3(m_currentVertex + 4, b); + m_vertices->SetColor(m_currentVertex + 4, color); + m_vertices->SetPosition3(m_currentVertex + 5, c); + m_vertices->SetColor(m_currentVertex + 5, color); + + m_currentVertex += 6; +} + +void GeometryDebugRenderer::End() +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + if (m_currentVertex > 0) + { + Matrix4x4 modelView = m_graphicsDevice->GetViewContext()->GetModelViewMatrix(); + Matrix4x4 projection = m_graphicsDevice->GetViewContext()->GetProjectionMatrix(); + + m_graphicsDevice->BindShader(m_graphicsDevice->GetDebugShader()); + m_graphicsDevice->GetDebugShader()->SetModelViewMatrix(modelView); + m_graphicsDevice->GetDebugShader()->SetProjectionMatrix(projection); + + m_renderState->Apply(); + m_graphicsDevice->BindVertexBuffer(m_vertices); + m_graphicsDevice->RenderLines(0, m_currentVertex / 2); + m_graphicsDevice->RenderPoints(0, m_currentVertex); + m_graphicsDevice->UnbindVertexBuffer(); + + m_graphicsDevice->UnbindShader(); + } + + m_begunRendering = FALSE; +} diff --git a/src/framework/graphics/geometrydebugrenderer.h b/src/framework/graphics/geometrydebugrenderer.h new file mode 100644 index 0000000..e203d62 --- /dev/null +++ b/src/framework/graphics/geometrydebugrenderer.h @@ -0,0 +1,162 @@ +#ifndef __FRAMEWORK_GRAPHICS_GEOMETRYDEBUGRENDERER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GEOMETRYDEBUGRENDERER_H_INCLUDED__ + +#include "../common.h" + +#include "color.h" + +class GraphicsDevice; +class RenderState; +class VertexBuffer; +struct BoundingBox; +struct BoundingSphere; +struct LineSegment; +struct Point3; +struct Ray; +struct Vector3; + +/** + * Helper class to render geometric primitives as wireframe shapes + * for debugging purposes. + */ +class GeometryDebugRenderer +{ +public: + /** + * Creates a geometry debug renderer. + * @param graphicsDevice the graphics device to use for rendering + * @param depthTesting TRUE to enable depth testing for all geometry rendering + */ + GeometryDebugRenderer(GraphicsDevice *graphicsDevice, BOOL depthTesting = FALSE); + + virtual ~GeometryDebugRenderer(); + + /** + * Begins a rendering block. All rendering should be performed after + * this and then completed with a call to End(). + */ + void Begin(); + + /** + * Renders a wireframe box. + * @param box the box to render + */ + void Render(const BoundingBox &box); + + /** + * Renders a wireframe box. + * @param box the box to render + * @param color the color to render with + */ + void Render(const BoundingBox &box, const Color &color); + + void Render(const Point3 &boxMin, const Point3 &boxMax); + void Render(const Point3 &boxMin, const Point3 &boxMax, const Color &color); + + /** + * Renders a wireframe sphere. + * @param sphere the sphere to render + */ + void Render(const BoundingSphere &sphere); + + /** + * Renders a wireframe sphere. + * @param sphere the sphere to render + * @param color the color to render with + */ + void Render(const BoundingSphere &sphere, const Color &color); + + /** + * Renders a wireframe ray up to a given length along the ray's direction. + * @param ray the ray to render + * @param length the length along the ray's direction to render + */ + void Render(const Ray &ray, float length); + + /** + * Renders a wireframe ray up to a given length along the ray's direction. + * @param ray the ray to render + * @param length the length along the ray's direction to render + * @param color1 the color to render the ray's origin with + * @param color2 the color to render the end point with + */ + void Render(const Ray &ray, float length, const Color &color1, const Color &color2); + + /** + * Renders a wireframe line segment. + * @param line the line segment to render + */ + void Render(const LineSegment &line); + + /** + * Renders a wireframe line segment. + * @param line the line segment to render + * @param color the color to render with + */ + void Render(const LineSegment &line, const Color &color); + + /** + * Renders a wireframe triangle. + * @param a the first point of the triangle + * @param b the second point of the triangle + * @param c the third point of the triangle + */ + void Render(const Vector3 &a, const Vector3 &b, const Vector3 &c); + + /** + * Renders a wireframe triangle. + * @param a the first point of the triangle + * @param b the second point of the triangle + * @param c the third point of the triangle + * @param color the color to render with + */ + void Render(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Color &color); + + /** + * Ends a rendering block, flushing out all Render() calls made + * to the video card. + */ + void End(); + +private: + GraphicsDevice *m_graphicsDevice; + RenderState *m_renderState; + Color m_color1; + Color m_color2; + VertexBuffer *m_vertices; + uint32_t m_currentVertex; + + BOOL m_begunRendering; +}; + +inline void GeometryDebugRenderer::Render(const BoundingBox &box) +{ + Render(box, m_color1); +} + +inline void GeometryDebugRenderer::Render(const Point3 &boxMin, const Point3 &boxMax) +{ + Render(boxMin, boxMax, m_color1); +} + +inline void GeometryDebugRenderer::Render(const BoundingSphere &sphere) +{ + Render(sphere, m_color1); +} + +inline void GeometryDebugRenderer::Render(const Ray &ray, float length) +{ + Render(ray, length, m_color1, m_color2); +} + +inline void GeometryDebugRenderer::Render(const LineSegment &line) +{ + Render(line, m_color1); +} + +inline void GeometryDebugRenderer::Render(const Vector3 &a, const Vector3 &b, const Vector3 &c) +{ + Render(a, b, c, m_color1); +} + +#endif diff --git a/src/framework/graphics/glincludes.h b/src/framework/graphics/glincludes.h new file mode 100644 index 0000000..6f01cb8 --- /dev/null +++ b/src/framework/graphics/glincludes.h @@ -0,0 +1,20 @@ + #ifndef __FRAMEWORK_GRAPHICS_GLINCLUDES_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GLINCLUDES_H_INCLUDED__ + +#ifdef DESKTOP + +// GLEW will include all necessary GL headers (e.g. gl.h, glu.h ... ) +#include + +#elif __S3E__ + +#include +#include + +#else + +#error Unknown platform + +#endif + +#endif diff --git a/src/framework/graphics/glutils.cpp b/src/framework/graphics/glutils.cpp new file mode 100644 index 0000000..c9dc81c --- /dev/null +++ b/src/framework/graphics/glutils.cpp @@ -0,0 +1,34 @@ +#include "../debug.h" + +#include "glutils.h" +#include + +BOOL IsGLExtensionPresent(const char* extension) +{ + STACK_TRACE; + ASSERT(extension != NULL); + ASSERT(strlen(extension) > 0); + + const char* extensionsList = (const char*)glGetString(GL_EXTENSIONS); + + return (strstr(extensionsList, extension) != NULL ? TRUE : FALSE); +} + +const char* GetGLErrorString(GLenum error) +{ + switch (error) + { + case GL_INVALID_ENUM: return "GL_INVALID_ENUM"; + case GL_INVALID_VALUE: return "GL_INVALID_VALUE"; + case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION"; +#ifdef MOBILE + case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION"; +#elif DESKTOP + case GL_STACK_OVERFLOW: return "GL_STACK_OVERFLOW"; + case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW"; +#endif + case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY"; + } + + return "Unknown error"; +} diff --git a/src/framework/graphics/glutils.h b/src/framework/graphics/glutils.h new file mode 100644 index 0000000..24fefdf --- /dev/null +++ b/src/framework/graphics/glutils.h @@ -0,0 +1,43 @@ +#ifndef __FRAMEWORK_GRAPHICS_GLUTILS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GLUTILS_H_INCLUDED__ + +#include "../common.h" +#include "glincludes.h" + +/** + * Checks if an OpenGL extension is present in the current + * implementation. This performs a case-sensitive string match. + * @param extension the name of the extension to check for. + * @return TRUE if the extension is present, FALSE if not + */ +BOOL IsGLExtensionPresent(const char* extension); + +/** + * Converts a OpenGL error code to a string equivalent. + * @param error the error code to convert + * @return a string equivalent of the given error code + */ +const char* GetGLErrorString(GLenum error); + +//#define GL_ERROR_DEBUG + +/** + * Macro wrapper for OpenGL calls which will call glGetError() + * immediately after to validate success if GL_ERROR_DEBUG is defined. + */ +#ifdef GL_ERROR_DEBUG + #include "../debug.h" + #include "../log.h" + #define GL_CALL(exp) \ + { \ + exp; \ + GLenum error = glGetError(); \ + if (error != GL_NO_ERROR) \ + LOG_ERROR(LOGCAT_OPENGL, "OpenGL error \"%s\" after: %s\n", GetGLErrorString(error), #exp); \ + ASSERT(error == GL_NO_ERROR); \ + } +#else + #define GL_CALL(exp) exp +#endif + +#endif diff --git a/src/framework/graphics/graphicscontextresource.h b/src/framework/graphics/graphicscontextresource.h new file mode 100644 index 0000000..50cafdd --- /dev/null +++ b/src/framework/graphics/graphicscontextresource.h @@ -0,0 +1,23 @@ +#ifndef __FRAMEWORK_GRAPHICS_GRAPHICSCONTEXTRESOURCE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GRAPHICSCONTEXTRESOURCE_H_INCLUDED__ + +/** + * Interface for objects whose lifecycle is tied to the current graphics + * context and should be made aware when the context is lost and/or + * recreated. + */ +class GraphicsContextResource +{ +public: + /** + * New OpenGL graphics context creation callback. + */ + virtual void OnNewContext() = 0; + + /** + * Lost OpenGL graphics context callback. + */ + virtual void OnLostContext() = 0; +}; + +#endif diff --git a/src/framework/graphics/graphicsdevice.cpp b/src/framework/graphics/graphicsdevice.cpp new file mode 100644 index 0000000..50b78d5 --- /dev/null +++ b/src/framework/graphics/graphicsdevice.cpp @@ -0,0 +1,774 @@ +#include "../debug.h" +#include "../log.h" + +#include "graphicsdevice.h" + +#include "blendstate.h" +#include "bufferobject.h" +#include "color.h" +#include "debugshader.h" +#include "framebuffer.h" +#include "framebufferdatatypes.h" +#include "geometrydebugrenderer.h" +#include "glincludes.h" +#include "glutils.h" +#include "graphicscontextresource.h" +#include "image.h" +#include "imageformats.h" +#include "indexbuffer.h" +#include "renderbuffer.h" +#include "renderstate.h" +#include "shader.h" +#include "simplecolorshader.h" +#include "simplecolortextureshader.h" +#include "simpletextureshader.h" +#include "simpletexturevertexlerpshader.h" +#include "simpletexturevertexskinningshader.h" +#include "standardshader.h" +#include "solidcolortexturecache.h" +#include "sprite2dshader.h" +#include "sprite3dshader.h" +#include "texture.h" +#include "textureformats.h" +#include "vertexattribs.h" +#include "vertexbuffer.h" +#include "viewcontext.h" +#include "../gamewindow.h" +#include "../screenorientation.h" +#include "../math/camera.h" +#include "../math/mathhelpers.h" + +// these are based on the OpenGL ES 2.0 spec minimum values +const unsigned int MAX_BOUND_TEXTURES = 8; +const unsigned int MAX_GPU_ATTRIB_SLOTS = 8; + +GraphicsDevice::GraphicsDevice(GameWindow *window) +{ + STACK_TRACE; + m_boundVertexBuffer = NULL; + m_boundIndexBuffer = NULL; + m_boundShader = NULL; + m_shaderVertexAttribsSet = FALSE; + + m_boundTextures = new const Texture*[MAX_BOUND_TEXTURES]; + m_boundFramebuffer = NULL; + m_boundRenderbuffer = NULL; + + m_enabledVertexAttribIndices.reserve(MAX_GPU_ATTRIB_SLOTS); + +#ifdef MOBILE + m_isDepthTextureSupported = IsGLExtensionPresent("OES_depth_texture"); + m_isNonPowerOfTwoTextureSupported = IsGLExtensionPresent("OES_texture_npot"); +#else + // TODO: Is this a good enough "catch-all" check for desktops? + m_isDepthTextureSupported = IsGLExtensionPresent("ARB_depth_texture"); + + m_isNonPowerOfTwoTextureSupported = IsGLExtensionPresent("ARB_texture_non_power_of_two"); +#endif + + LOG_INFO(LOGCAT_GRAPHICS, "Support for depth textures was %s.\n", m_isDepthTextureSupported ? "found" : "not found"); + LOG_INFO(LOGCAT_GRAPHICS, "Support for NPOT textures was %s.\n", m_isNonPowerOfTwoTextureSupported ? "found" : "not found"); + + m_window = window; + + m_activeViewContext = NULL; + m_defaultViewContext = new ViewContext(); + m_defaultViewContext->Create(this); + m_activeViewContext = m_defaultViewContext; + + m_currentTextureParams = TEXPARAM_DEFAULT; + + m_debugRenderer = NULL; + + m_solidColorTextures = new SolidColorTextureCache(this); + + m_simpleColorShader = new SimpleColorShader(); + m_simpleColorTextureShader = new SimpleColorTextureShader(); + m_simpleTextureShader = new SimpleTextureShader(); + m_simpleTextureVertexLerpShader = new SimpleTextureVertexLerpShader(); + m_simpleTextureVertexSkinningShader = new SimpleTextureVertexSkinningShader(); + m_sprite2dShader = new Sprite2DShader(); + m_sprite3dShader = new Sprite3DShader(); + m_debugShader = new DebugShader(); + + RegisterManagedResource(m_simpleColorShader); + RegisterManagedResource(m_simpleColorTextureShader); + RegisterManagedResource(m_simpleTextureShader); + RegisterManagedResource(m_simpleTextureVertexLerpShader); + RegisterManagedResource(m_simpleTextureVertexSkinningShader); + RegisterManagedResource(m_sprite2dShader); + RegisterManagedResource(m_sprite3dShader); + RegisterManagedResource(m_debugShader); +} + +GraphicsDevice::~GraphicsDevice() +{ + STACK_TRACE; + UnregisterManagedResource(m_simpleColorShader); + UnregisterManagedResource(m_simpleColorTextureShader); + UnregisterManagedResource(m_simpleTextureShader); + UnregisterManagedResource(m_simpleTextureVertexLerpShader); + UnregisterManagedResource(m_simpleTextureVertexSkinningShader); + UnregisterManagedResource(m_sprite2dShader); + UnregisterManagedResource(m_sprite3dShader); + UnregisterManagedResource(m_debugShader); + + SAFE_DELETE(m_defaultViewContext); + SAFE_DELETE(m_debugRenderer); + SAFE_DELETE(m_solidColorTextures); + SAFE_DELETE(m_simpleColorShader); + SAFE_DELETE(m_simpleColorTextureShader); + SAFE_DELETE(m_simpleTextureShader); + SAFE_DELETE(m_simpleTextureVertexLerpShader); + SAFE_DELETE(m_simpleTextureVertexSkinningShader); + SAFE_DELETE(m_sprite2dShader); + SAFE_DELETE(m_sprite3dShader); + SAFE_DELETE(m_debugShader); + SAFE_DELETE_ARRAY(m_boundTextures); +} + +void GraphicsDevice::OnNewContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GRAPHICS, "Initializing default state for new OpenGL context.\n"); + + m_activeViewContext->OnNewContext(); + + RENDERSTATE_DEFAULT.Apply(); + BLENDSTATE_DEFAULT.Apply(); + + UnbindVertexBuffer(); + UnbindIndexBuffer(); + for (uint32_t i = 0; i < MAX_BOUND_TEXTURES; ++i) + UnbindTexture(i); + UnbindShader(); + UnbindRenderbuffer(); + UnbindFramebuffer(); + + m_debugRenderer = new GeometryDebugRenderer(this); + + m_solidColorTextures->OnNewContext(); + + for (ManagedResourceList::iterator i = m_managedResources.begin(); i != m_managedResources.end(); ++i) + (*i)->OnNewContext(); +} + +void GraphicsDevice::OnLostContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_GRAPHICS, "Cleaning up objects/state specific to the lost OpenGL context.\n"); + + m_activeViewContext->OnLostContext(); + + SAFE_DELETE(m_debugRenderer); + + m_solidColorTextures->OnLostContext(); + + for (ManagedResourceList::iterator i = m_managedResources.begin(); i != m_managedResources.end(); ++i) + (*i)->OnLostContext(); +} + +void GraphicsDevice::OnResize(const Rect &size) +{ + STACK_TRACE; + + LOG_INFO(LOGCAT_GRAPHICS, "Window resized (%d, %d) - (%d, %d).\n", size.left, size.top, size.GetWidth(), size.GetHeight()); + if (m_window->GetScreenOrientation() != SCREEN_ANGLE_0) + LOG_INFO(LOGCAT_GRAPHICS, "Screen is rotated (angle = %d).\n", (int)m_window->GetScreenOrientation()); + m_activeViewContext->OnResize(size, m_window->GetScreenOrientation()); +} + +void GraphicsDevice::OnRender() +{ + STACK_TRACE; + GLenum error = glGetError(); + ASSERT(error == GL_NO_ERROR); + if (error != GL_NO_ERROR) + { + LOG_ERROR(LOGCAT_OPENGL, "OpenGL error \"%s\"\n", GetGLErrorString(error)); + + // keep checking for and reporting errors until there are no more left + while ((error = glGetError()) != GL_NO_ERROR) + LOG_ERROR(LOGCAT_OPENGL, "OpenGL error \"%s\"\n", GetGLErrorString(error)); + } + + m_activeViewContext->OnRender(); +} + +void GraphicsDevice::Clear(float r, float g, float b, float a) +{ + STACK_TRACE; + GL_CALL(glClearColor(r, g, b, a)); + GL_CALL(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)); +} + +void GraphicsDevice::Clear(const Color &color) +{ + STACK_TRACE; + Clear(color.r, color.g, color.b, color.a); +} + +Texture* GraphicsDevice::GetSolidColorTexture(const Color &color) +{ + STACK_TRACE; + return m_solidColorTextures->Get(color); +} + +void GraphicsDevice::BindTexture(const Texture *texture, uint32_t unit) +{ + STACK_TRACE; + ASSERT(unit < MAX_BOUND_TEXTURES); + ASSERT(texture != NULL); + ASSERT(texture->IsInvalidated() == FALSE); + if (texture != m_boundTextures[unit]) + { + GL_CALL(glActiveTexture(GL_TEXTURE0 + unit)); + GL_CALL(glBindTexture(GL_TEXTURE_2D, texture->GetTextureName())); + } + m_boundTextures[unit] = texture; +} + +void GraphicsDevice::BindSolidColorTexture(const Color &color, uint32_t unit) +{ + STACK_TRACE; + Texture *texture = m_solidColorTextures->Get(color); + BindTexture(texture, unit); +} + +void GraphicsDevice::UnbindTexture(uint32_t unit) +{ + STACK_TRACE; + ASSERT(unit < MAX_BOUND_TEXTURES); + GL_CALL(glActiveTexture(GL_TEXTURE0 + unit)); + GL_CALL(glBindTexture(GL_TEXTURE_2D, 0)); + m_boundTextures[unit] = NULL; +} + +void GraphicsDevice::UnbindTexture(const Texture *texture) +{ + STACK_TRACE; + ASSERT(texture != NULL); + if (texture == NULL) + return; + + for (uint32_t i = 0; i < MAX_BOUND_TEXTURES; ++i) + { + if (m_boundTextures[i] == texture) + UnbindTexture(i); + } +} + +void GraphicsDevice::BindRenderbuffer(Renderbuffer *renderbuffer) +{ + STACK_TRACE; + ASSERT(renderbuffer != NULL); + ASSERT(renderbuffer->IsInvalidated() == FALSE); + if (m_boundRenderbuffer != renderbuffer) + { + GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer->GetRenderbufferName())); + m_boundRenderbuffer = renderbuffer; + } +} + +void GraphicsDevice::UnbindRenderbuffer() +{ + STACK_TRACE; + GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0)); + m_boundRenderbuffer = NULL; +} + +void GraphicsDevice::UnbindRenderBuffer(Renderbuffer *renderBuffer) +{ + STACK_TRACE; + ASSERT(renderBuffer != NULL); + if (renderBuffer == NULL) + return; + + if (m_boundRenderbuffer == renderBuffer) + UnbindRenderbuffer(); +} + +void GraphicsDevice::BindFramebuffer(Framebuffer *framebuffer) +{ + STACK_TRACE; + ASSERT(framebuffer != NULL); + ASSERT(framebuffer->IsInvalidated() == FALSE); + if (m_boundFramebuffer != framebuffer) + { + GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, framebuffer->GetFramebufferName())); + m_boundFramebuffer = framebuffer; + m_boundFramebuffer->OnBind(); + } +} + +void GraphicsDevice::UnbindFramebuffer() +{ + STACK_TRACE; + GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0)); + if (m_boundFramebuffer != NULL) + m_boundFramebuffer->OnUnBind(); + m_boundFramebuffer = NULL; +} + +void GraphicsDevice::UnbindFramebuffer(Framebuffer *framebuffer) +{ + STACK_TRACE; + ASSERT(framebuffer != NULL); + if (framebuffer == NULL) + return; + + if (m_boundFramebuffer == framebuffer) + UnbindFramebuffer(); +} + +void GraphicsDevice::SetViewContext(ViewContext *viewContext) +{ + STACK_TRACE; + if (viewContext == m_activeViewContext) + return; // nothing has changed + + if (viewContext != NULL) + m_activeViewContext = viewContext; + else + m_activeViewContext = m_defaultViewContext; + + m_activeViewContext->OnApply(m_window->GetRect(), m_window->GetScreenOrientation()); +} + +void GraphicsDevice::RegisterManagedResource(GraphicsContextResource *resource) +{ + STACK_TRACE; + ASSERT(resource != NULL); + + // make sure this resource isn't in our list already + stl::list::iterator i; + for (ManagedResourceList::iterator i = m_managedResources.begin(); i != m_managedResources.end(); ++i) + { + ASSERT((*i) != resource); + if ((*i) == resource) + return; + } + + m_managedResources.push_back(resource); +} + +void GraphicsDevice::UnregisterManagedResource(GraphicsContextResource *resource) +{ + STACK_TRACE; + ASSERT(resource != NULL); + m_managedResources.remove(resource); +} + +void GraphicsDevice::UnregisterAllManagedResources() +{ + STACK_TRACE; + m_managedResources.clear(); +} + +void GraphicsDevice::BindVertexBuffer(VertexBuffer *buffer) +{ + STACK_TRACE; + ASSERT(buffer != NULL); + ASSERT(buffer->GetNumElements() > 0); + + // don't bind this buffer if it's already bound! + if (m_boundVertexBuffer == buffer) + return; + + if (!buffer->IsClientSideBuffer()) + BindVBO(buffer); + else + BindClientBuffer(buffer); + + m_boundVertexBuffer = buffer; + if (m_shaderVertexAttribsSet) + ClearSetShaderVertexAttributes(); +} + +void GraphicsDevice::UnbindVertexBuffer() +{ + STACK_TRACE; + GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); + + m_boundVertexBuffer = NULL; + if (m_shaderVertexAttribsSet) + ClearSetShaderVertexAttributes(); +} + +void GraphicsDevice::BindIndexBuffer(IndexBuffer *buffer) +{ + STACK_TRACE; + ASSERT(buffer != NULL); + ASSERT(buffer->GetNumElements() > 0); + + // don't bind this buffer if it's already bound! + if (m_boundIndexBuffer == buffer) + return; + + if (!buffer->IsClientSideBuffer()) + BindIBO(buffer); + else + BindClientBuffer(buffer); + + m_boundIndexBuffer = buffer; +} + +void GraphicsDevice::UnbindIndexBuffer() +{ + STACK_TRACE; + GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); + + m_boundIndexBuffer = NULL; +} + +void GraphicsDevice::BindShader(Shader *shader) +{ + STACK_TRACE; + ASSERT(shader != NULL); + ASSERT(shader->IsReadyForUse() == TRUE); + GL_CALL(glUseProgram(shader->GetProgramId())); + + m_boundShader = shader; + if (m_shaderVertexAttribsSet) + ClearSetShaderVertexAttributes(); + + m_boundShader->OnBind(); +} + +void GraphicsDevice::UnbindShader() +{ + STACK_TRACE; + GL_CALL(glUseProgram(0)); + + if (m_boundShader != NULL) + m_boundShader->OnUnbind(); + + m_boundShader = NULL; + if (m_shaderVertexAttribsSet) + ClearSetShaderVertexAttributes(); +} + +void GraphicsDevice::BindVBO(VertexBuffer *buffer) +{ + STACK_TRACE; + if (buffer->IsDirty()) + buffer->Update(); + + GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer->GetBufferId())); +} + +void GraphicsDevice::BindClientBuffer(VertexBuffer *buffer) +{ + STACK_TRACE; + GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); +} + +void GraphicsDevice::BindIBO(IndexBuffer *buffer) +{ + STACK_TRACE; + if (buffer->IsDirty()) + buffer->Update(); + + GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer->GetBufferId())); +} + +void GraphicsDevice::BindClientBuffer(IndexBuffer *buffer) +{ + STACK_TRACE; + GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); +} + +void GraphicsDevice::SetShaderVertexAttributes() +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + ASSERT(m_boundShader != NULL); + ASSERT(m_enabledVertexAttribIndices.empty() == TRUE); + ASSERT(m_boundVertexBuffer->GetNumAttributes() >= m_boundShader->GetNumAttributes()); + + uint32_t numAttributes = m_boundShader->GetNumAttributes(); + for (uint32_t i = 0; i < numAttributes; ++i) + { + int32_t bufferAttribIndex = 0; + if (m_boundShader->IsAttributeMappedToStandardType(i)) + { + VERTEX_ATTRIBS standardType = m_boundShader->GetAttributeMappedStandardType(i); + bufferAttribIndex = m_boundVertexBuffer->GetIndexOfStandardAttrib(standardType); + ASSERT(bufferAttribIndex != -1); + if (bufferAttribIndex == -1) + continue; + } + else + bufferAttribIndex = m_boundShader->GetAttributeMappedBufferIndex(i); + + uint32_t offset = 0; + GLint size = 0; + + const VertexBufferAttribute *bufferAttribInfo = m_boundVertexBuffer->GetAttributeInfo((uint32_t)bufferAttribIndex); + size = bufferAttribInfo->size; + offset = bufferAttribInfo->offset; + ASSERT(size != 0); + + // convert the offset into a pointer + // client-side vertex data has a full pointer to the first element of the attribute data + // VBO just specifies an offset in bytes from zero to the first element of the attribute data + const void *buffer = NULL; + if (m_boundVertexBuffer->IsClientSideBuffer()) + buffer = (float*)m_boundVertexBuffer->GetBuffer() + offset; + else + buffer = (int8_t*)NULL + (offset * sizeof(float)); + + GL_CALL(glEnableVertexAttribArray(i)); + GL_CALL(glVertexAttribPointer(i, size, GL_FLOAT, FALSE, m_boundVertexBuffer->GetElementWidthInBytes(), buffer)); + + m_enabledVertexAttribIndices.push_back(i); + } + + m_shaderVertexAttribsSet = TRUE; +} + +void GraphicsDevice::ClearSetShaderVertexAttributes() +{ + STACK_TRACE; + while (!m_enabledVertexAttribIndices.empty()) + { + uint32_t index = m_enabledVertexAttribIndices.back(); + m_enabledVertexAttribIndices.pop_back(); + GL_CALL(glDisableVertexAttribArray(index)); + } + + m_shaderVertexAttribsSet = FALSE; +} + +void GraphicsDevice::RenderTriangles(const IndexBuffer *buffer) +{ + STACK_TRACE; + ASSERT(buffer != NULL); + ASSERT(buffer->IsClientSideBuffer() == TRUE); + ASSERT(m_boundVertexBuffer != NULL); + ASSERT(m_boundIndexBuffer == NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + int numVertices = buffer->GetNumElements(); + ASSERT(numVertices % 3 == 0); + GL_CALL(glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_SHORT, buffer->GetBuffer())); +} + +void GraphicsDevice::RenderTriangles() +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + int numIndices = m_boundIndexBuffer->GetNumElements(); + ASSERT(numIndices % 3 == 0); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = m_boundIndexBuffer->GetBuffer(); + else + offset = NULL; + + GL_CALL(glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the whole vertex buffer + ASSERT(m_boundVertexBuffer->GetNumElements() % 3 == 0); + GL_CALL(glDrawArrays(GL_TRIANGLES, 0, m_boundVertexBuffer->GetNumElements())); + } +} + +void GraphicsDevice::RenderTriangles(uint32_t startVertex, uint32_t numTriangles) +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + uint32_t numVertices = numTriangles * 3; + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + ASSERT((m_boundIndexBuffer->GetNumElements() - startVertex) >= numVertices); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + uint32_t indexOffset = startVertex * m_boundIndexBuffer->GetElementWidthInBytes(); + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = ((int8_t*)m_boundIndexBuffer->GetBuffer() + indexOffset); + else + offset = ((int8_t*)NULL + indexOffset); + + GL_CALL(glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the given range using only the bound vertex buffer + ASSERT((m_boundVertexBuffer->GetNumElements() - startVertex) >= numVertices); + GL_CALL(glDrawArrays(GL_TRIANGLES, startVertex, numVertices)); + } +} + +void GraphicsDevice::RenderLines(const IndexBuffer *buffer) +{ + STACK_TRACE; + ASSERT(buffer != NULL); + ASSERT(buffer->IsClientSideBuffer() == TRUE); + ASSERT(m_boundVertexBuffer != NULL); + ASSERT(m_boundIndexBuffer == NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + uint32_t numVertices = buffer->GetNumElements(); + ASSERT(numVertices % 2 == 0); + GL_CALL(glDrawElements(GL_LINES, numVertices, GL_UNSIGNED_SHORT, buffer->GetBuffer())); +} + +void GraphicsDevice::RenderLines() +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + int numIndices = m_boundIndexBuffer->GetNumElements(); + ASSERT(numIndices % 2 == 0); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = m_boundIndexBuffer->GetBuffer(); + else + offset = NULL; + + GL_CALL(glDrawElements(GL_LINES, numIndices, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the whole vertex buffer + ASSERT(m_boundVertexBuffer->GetNumElements() % 2 == 0); + GL_CALL(glDrawArrays(GL_LINES, 0, m_boundVertexBuffer->GetNumElements())); + } +} + +void GraphicsDevice::RenderLines(uint32_t startVertex, uint32_t numLines) +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + uint32_t numVertices = numLines * 2; + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + ASSERT((m_boundIndexBuffer->GetNumElements() - startVertex) >= numVertices); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + uint32_t indexOffset = startVertex * m_boundIndexBuffer->GetElementWidthInBytes(); + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = ((int8_t*)m_boundIndexBuffer->GetBuffer() + indexOffset); + else + offset = ((int8_t*)NULL + indexOffset); + + GL_CALL(glDrawElements(GL_LINES, numVertices, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the given range using only the bound vertex buffer + ASSERT((m_boundVertexBuffer->GetNumElements() - startVertex) >= numVertices); + GL_CALL(glDrawArrays(GL_LINES, startVertex, numVertices)); + } +} + +void GraphicsDevice::RenderPoints(const IndexBuffer *buffer) +{ + STACK_TRACE; + ASSERT(buffer != NULL); + ASSERT(buffer->IsClientSideBuffer() == TRUE); + ASSERT(m_boundVertexBuffer != NULL); + ASSERT(m_boundIndexBuffer == NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + uint32_t numVertices = buffer->GetNumElements(); + GL_CALL(glDrawElements(GL_POINTS, numVertices, GL_UNSIGNED_SHORT, buffer->GetBuffer())); +} + +void GraphicsDevice::RenderPoints() +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + int numIndices = m_boundIndexBuffer->GetNumElements(); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = m_boundIndexBuffer->GetBuffer(); + else + offset = NULL; + + GL_CALL(glDrawElements(GL_POINTS, numIndices, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the whole vertex buffer + GL_CALL(glDrawArrays(GL_POINTS, 0, m_boundVertexBuffer->GetNumElements())); + } +} + +void GraphicsDevice::RenderPoints(uint32_t startVertex, uint32_t numPoints) +{ + STACK_TRACE; + ASSERT(m_boundVertexBuffer != NULL); + if (!m_shaderVertexAttribsSet) + SetShaderVertexAttributes(); + + if (m_boundIndexBuffer != NULL) + { + // using bound index buffer + ASSERT((m_boundIndexBuffer->GetNumElements() - startVertex) >= numPoints); + + // get the offset from the beginning of the index buffer to start rendering at + // client buffer is just a raw pointer to the first index to use + // IBO is basically the same idea, but the pointer "starts" at NULL and goes from there + uint32_t indexOffset = startVertex * m_boundIndexBuffer->GetElementWidthInBytes(); + const void *offset; + if (m_boundIndexBuffer->IsClientSideBuffer()) + offset = ((int8_t*)m_boundIndexBuffer->GetBuffer() + indexOffset); + else + offset = ((int8_t*)NULL + indexOffset); + + GL_CALL(glDrawElements(GL_POINTS, numPoints, GL_UNSIGNED_SHORT, offset)); + } + else + { + // no index buffer, just render the given range using only the bound vertex buffer + ASSERT((m_boundVertexBuffer->GetNumElements() - startVertex) >= numPoints); + GL_CALL(glDrawArrays(GL_POINTS, startVertex, numPoints)); + } +} diff --git a/src/framework/graphics/graphicsdevice.h b/src/framework/graphics/graphicsdevice.h new file mode 100644 index 0000000..151ed3d --- /dev/null +++ b/src/framework/graphics/graphicsdevice.h @@ -0,0 +1,404 @@ +#ifndef __FRAMEWORK_GRAPHICS_GRAPHICSDEVICE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GRAPHICSDEVICE_H_INCLUDED__ + +#include "../common.h" + +#include "framebufferdatatypes.h" +#include "textureformats.h" +#include "textureparameters.h" +#include "../math/rect.h" + +#include +#include + +class BufferObject; +class DebugShader; +class Framebuffer; +class GameWindow; +class GeometryDebugRenderer; +class GraphicsContextResource; +class Image; +class IndexBuffer; +class Renderbuffer; +class Shader; +class SimpleColorShader; +class SimpleColorTextureShader; +class SimpleTextureShader; +class SimpleTextureVertexLerpShader; +class SimpleTextureVertexSkinningShader; +class SolidColorTextureCache; +class Sprite2DShader; +class Sprite3DShader; +class Texture; +class VertexBuffer; +class ViewContext; +struct Color; + +typedef stl::list ManagedResourceList; +typedef stl::vector EnabledVertexAttribList; + +/** + * Provides an abstraction over the underlying OpenGL context. + */ +class GraphicsDevice +{ +public: + /** + * Creates a graphics device object based on a parent window that is + * hosting the OpenGL context. + * @param window a window with an active OpenGL context associated with it + */ + GraphicsDevice(GameWindow *window); + + virtual ~GraphicsDevice(); + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + + /** + * Viewport resize callback. + * @param size the new viewport size + */ + void OnResize(const Rect &size); + + /** + * Render callback. + */ + void OnRender(); + + /** + * Clears the display. + * @param r red component of the color to clear the display to + * @param g green component of the color to clear the display to + * @param b blue component of the color to clear the display to + * @param a alpha component of the color to clear the display to + */ + void Clear(float r, float g, float b, float a); + + /** + * Clears the display. + * @param color the color to clear the display to + */ + void Clear(const Color &color); + + /** + * Gets a texture that is filled with a single solid color. + * @param the color to get a texture for + * @return the texture or NULL on failure + */ + Texture* GetSolidColorTexture(const Color &color); + + /** + * Binds a texture for rendering. + * @param texture the texture to bind + * @param unit the texture unit to bind to + */ + void BindTexture(const Texture *texture, uint32_t unit = 0); + + /** + * Binds a texture that is filled with the specified solid color. + * @param color a color with which to find and bind a texture with + * @param unit the texture unit that the solid color texture should be bound to + */ + void BindSolidColorTexture(const Color &color, uint32_t unit = 0); + + /** + * Unbinds the currently bound texture. + * @param unit the texture unit to be unbound + */ + void UnbindTexture(uint32_t unit = 0); + + /** + * Unbinds the specified texture only if it's bound already. If it's not + * currently bound this method will do nothing. + * @param texture the texture to be unbound + */ + void UnbindTexture(const Texture *texture); + + /** + * Sets the current texture parameters which all subsequent + * texture management calls will use. + * @param params the texture parameters to set + */ + void SetTextureParameters(const TextureParameters ¶ms); + + /** + * @return the currently applied texture parameters + */ + const TextureParameters* GetTextureParameters() const { return &m_currentTextureParams; } + + /** + * Binds a renderbuffer. + * @param renderbuffer the renderbuffer to bind + */ + void BindRenderbuffer(Renderbuffer *renderbuffer); + + /** + * Unbinds the currently bound renderbuffer. + */ + void UnbindRenderbuffer(); + + /** + * Unbinds the specified renderbuffer only if it's bound already. If it's + * not currently bound this method will do nothing. + * @param renderbuffer the renderbuffer to be unbound + */ + void UnbindRenderBuffer(Renderbuffer *renderBuffer); + + /** + * Binds a framebuffer. + * @param framebuffer the framebuffer to bind + */ + void BindFramebuffer(Framebuffer *framebuffer); + + /** + * Unbinds the currently bound framebuffer + */ + void UnbindFramebuffer(); + + /** + * Unbinds the specified framebuffer only if it's bound already. If it's + * not currently bound this method will do nothing. + * @param framebuffer the framebuffer to be unbound + */ + void UnbindFramebuffer(Framebuffer *framebuffer); + + /** + * @return the current ViewContext object + */ + ViewContext* GetViewContext() const { return m_activeViewContext; } + + /** + * Sets a new active ViewContext which will be applied immediately. + * If a NULL pointer is given, the default ViewContext will be + * restored. + * @param viewContext the new ViewContext to apply, or NULL to restore + * the original one + */ + void SetViewContext(ViewContext *viewContext); + + /** + * Registers a resource to have it's lifecycle management events + * raised automatically. + * @param resource the resource to be registered + */ + void RegisterManagedResource(GraphicsContextResource *resource); + + /** + * Unregisters a resource that was previously registered. It's lifecycle + * management events will no longer be raised automatically. + * @param resource the resource to be unregistered + */ + void UnregisterManagedResource(GraphicsContextResource *resource); + + /** + * Unregisters all resources that were previously registered. Their + * lifecycle management events will no longer be raised automatically. + */ + void UnregisterAllManagedResources(); + + /** + * Binds a vertex buffer for rendering. If the buffer has an associated + * VBO it's contents will be uploaded to video memory if necessary. + * @param buffer the vertex buffer to bind + */ + void BindVertexBuffer(VertexBuffer *buffer); + + /** + * Unbinds a vertex buffer. + */ + void UnbindVertexBuffer(); + + /** + * Binds an index buffer for rendering. If the buffer has an associated + * IBO it's contents will be uploaded to video memory if necessary. + * @param buffer the index buffer to bind + */ + void BindIndexBuffer(IndexBuffer *buffer); + + /** + * Unbinds an index buffer. + */ + void UnbindIndexBuffer(); + + /** + * Binds a shader for rendering. + * @param shader the shader to bind + */ + void BindShader(Shader *shader); + + /** + * Unbinds any currently bound shader. + */ + void UnbindShader(); + + /** + * Renders the currently bound vertex buffer as triangles. + * @param buffer index buffer containing indices of the vertices to be rendered + */ + void RenderTriangles(const IndexBuffer *buffer); + + /** + * Renders the currently bound vertex buffer as triangles. + */ + void RenderTriangles(); + + /** + * Renders the currently bound vertex buffer as triangles. + * @param startVertex the index of the first vertex to be rendered + * @param numTriangles the number of triangles to be rendered + */ + void RenderTriangles(uint32_t startVertex, uint32_t numTriangles); + + /** + * Renders the currently bound vertex buffer as lines. + * @param buffer index buffer containing indices of the vertices to be rendered + */ + void RenderLines(const IndexBuffer *buffer); + + /** + * Renders the currently bound vertex buffer as lines. + */ + void RenderLines(); + + /** + * Renders the currently bound vertex buffer as lines. + * @param startVertex the index of the first vertex to be rendered + * @param numLines the number of lines to be rendered + */ + void RenderLines(uint32_t startVertex, uint32_t numLines); + + /** + * Renders the currently bound vertex buffer as points. + */ + void RenderPoints(const IndexBuffer *buffer); + + /** + * Renders the currently bound vertex buffer as points. + */ + void RenderPoints(); + + /** + * Renders the currently bound vertex buffer as points. + * @param startVertex the index of the first vertex to be rendered + * @param numPoints the number of points to be rendered + */ + void RenderPoints(uint32_t startVertex, uint32_t numPoints); + + /** + * @return a debug geometry renderer + */ + GeometryDebugRenderer* GetDebugRenderer() const { return m_debugRenderer; } + + /** + * @return built-in shader + */ + SimpleColorShader* GetSimpleColorShader() const { return m_simpleColorShader; } + + /** + * @return built-in shader + */ + SimpleColorTextureShader* GetSimpleColorTextureShader() const { return m_simpleColorTextureShader; } + + /** + * @return built-in shader + */ + SimpleTextureShader* GetSimpleTextureShader() const { return m_simpleTextureShader; } + + /** + * @return built-in shader + */ + Sprite2DShader* GetSprite2DShader() const { return m_sprite2dShader; } + + /** + * @return built-in shader + */ + Sprite3DShader* GetSprite3DShader() const { return m_sprite3dShader; } + + SimpleTextureVertexLerpShader* GetSimpleTextureVertexLerpShader() const { return m_simpleTextureVertexLerpShader; } + SimpleTextureVertexSkinningShader* GetSimpleTextureVertexSkinningShader() const { return m_simpleTextureVertexSkinningShader; } + + /** + * @return built-in shader + */ + DebugShader* GetDebugShader() const { return m_debugShader; } + + /** + * @return TRUE if depth textures are supported + */ + BOOL IsDepthTextureSupported() const { return m_isDepthTextureSupported; } + + /** + * @return TRUE if textures with dimensions that are not a power of two + * are supported + */ + BOOL IsNonPowerOfTwoTextureSupported() const { return m_isNonPowerOfTwoTextureSupported; } + + /** + * @return the parent window object that this graphics device is for + */ + GameWindow* GetWindow() const { return m_window; } + +private: + void BindVBO(VertexBuffer *buffer); + void BindClientBuffer(VertexBuffer *buffer); + void BindIBO(IndexBuffer *buffer); + void BindClientBuffer(IndexBuffer *buffer); + + BOOL IsReadyToRender() const; + + void SetShaderVertexAttributes(); + void ClearSetShaderVertexAttributes(); + + ManagedResourceList m_managedResources; + + Framebuffer *m_boundFramebuffer; + const Renderbuffer *m_boundRenderbuffer; + const VertexBuffer *m_boundVertexBuffer; + const IndexBuffer *m_boundIndexBuffer; + const Texture **m_boundTextures; + Shader *m_boundShader; + BOOL m_shaderVertexAttribsSet; + EnabledVertexAttribList m_enabledVertexAttribIndices; + BOOL m_isDepthTextureSupported; + BOOL m_isNonPowerOfTwoTextureSupported; + + GameWindow *m_window; + ViewContext *m_defaultViewContext; + ViewContext *m_activeViewContext; + TextureParameters m_currentTextureParams; + + GeometryDebugRenderer *m_debugRenderer; + SolidColorTextureCache *m_solidColorTextures; + + SimpleColorShader *m_simpleColorShader; + SimpleColorTextureShader *m_simpleColorTextureShader; + SimpleTextureShader *m_simpleTextureShader; + SimpleTextureVertexLerpShader *m_simpleTextureVertexLerpShader; + SimpleTextureVertexSkinningShader *m_simpleTextureVertexSkinningShader; + Sprite2DShader *m_sprite2dShader; + Sprite3DShader *m_sprite3dShader; + DebugShader *m_debugShader; +}; + +inline void GraphicsDevice::SetTextureParameters(const TextureParameters ¶ms) +{ + m_currentTextureParams = params; +} + +inline BOOL GraphicsDevice::IsReadyToRender() const +{ + if (m_boundShader != NULL && m_boundVertexBuffer != NULL && m_shaderVertexAttribsSet) + return TRUE; + else + return FALSE; +} + +#endif diff --git a/src/framework/graphics/gridtextureatlas.cpp b/src/framework/graphics/gridtextureatlas.cpp new file mode 100644 index 0000000..6be2f21 --- /dev/null +++ b/src/framework/graphics/gridtextureatlas.cpp @@ -0,0 +1,62 @@ +#include "../debug.h" + +#include "gridtextureatlas.h" + +#include "texture.h" + +GridTextureAtlas::GridTextureAtlas(uint16_t textureWidth, uint16_t textureHeight, uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder, float texCoordEdgeOffset) + : TextureAtlas(textureWidth, textureHeight, texCoordEdgeOffset) +{ + STACK_TRACE; + GenerateGrid(tileWidth, tileHeight, tileBorder); +} + +GridTextureAtlas::GridTextureAtlas(Texture *source, uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder, float texCoordEdgeOffset) + : TextureAtlas(source, texCoordEdgeOffset) +{ + STACK_TRACE; + GenerateGrid(tileWidth, tileHeight, tileBorder); +} + +GridTextureAtlas::~GridTextureAtlas() +{ + STACK_TRACE; +} + +void GridTextureAtlas::GenerateGrid(uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder) +{ + STACK_TRACE; + m_tileWidth = tileWidth; + m_tileHeight = tileHeight; + + tileWidth += tileBorder; + tileHeight += tileBorder; + + uint16_t tilesX = (GetWidth() - tileBorder) / (m_tileWidth + tileBorder); + uint16_t tilesY = (GetHeight() - tileBorder) / (m_tileHeight + tileBorder); + + m_tiles.resize(tilesX * tilesY); + + for (uint16_t y = 0; y < tilesY; ++y) + { + for (uint16_t x = 0; x < tilesX; ++x) + { + TextureAtlasTile *current = &m_tiles[(y * tilesX) + x]; + + // set pixel location/dimensions + current->dimensions.left = tileBorder + x * tileWidth; + current->dimensions.top = tileBorder + y * tileHeight; + current->dimensions.right = current->dimensions.left + tileWidth - tileBorder; + current->dimensions.bottom = current->dimensions.top + tileHeight - tileBorder; + + // set texture coordinates + // HACK: subtract GetTexCoordEdgeOffset() from the bottom right edges to + // get around floating point rounding errors (adjacent tiles will + // slightly bleed in otherwise) + current->texCoords.left = (current->dimensions.left - tileBorder + GetTexCoordEdgeOffset()) / (float)GetWidth(); + current->texCoords.top = (current->dimensions.top - tileBorder + GetTexCoordEdgeOffset()) / (float)GetHeight(); + current->texCoords.right = ((float)current->dimensions.right + tileBorder - GetTexCoordEdgeOffset()) / (float)GetWidth(); + current->texCoords.bottom = ((float)current->dimensions.bottom + tileBorder - GetTexCoordEdgeOffset()) / (float)GetHeight(); + } + } +} diff --git a/src/framework/graphics/gridtextureatlas.h b/src/framework/graphics/gridtextureatlas.h new file mode 100644 index 0000000..d694df4 --- /dev/null +++ b/src/framework/graphics/gridtextureatlas.h @@ -0,0 +1,63 @@ +#ifndef __FRAMEWORK_GRAPHICS_GRIDTEXTUREATLAS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_GRIDTEXTUREATLAS_H_INCLUDED__ + +#include "../common.h" + +#include "textureatlas.h" + +class Texture; + +/** + * Texture atlas manager which divides the texture evenly into a grid + * of similarly sized sub-textures / tiles. + */ +class GridTextureAtlas : public TextureAtlas +{ +public: + /** + * Creates a texture atlas object with the specified properties. + * @param textureWidth the width in pixels of the texture that will + * be used for this atlas + * @param textureHeight the height in pixels of the texture that + * will be used for this atlas + * @param tileWidth the width in pixels of each sub-texture / tile + * @param tileHeight the height in pixels of each sub-texture / tile + * @param tileBorder the number of pixels between each sub-texture / tile + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + GridTextureAtlas(uint16_t textureWidth, uint16_t textureHeight, uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder = 0, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + /** + * Creates a texture atlas object with the specified properties. + * @param source the underlying texture to use for this atlas + * @param tileWidth the width in pixels of each sub-texture / tile + * @param tileHeight the height in pixels of each sub-texture / tile + * @param tileBorder the number of pixels between each sub-texture / tile + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + GridTextureAtlas(Texture *source, uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder = 0, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + virtual ~GridTextureAtlas(); + + /** + * @return width in pixels of each sub-texture / tile + */ + uint16_t GetTileWidth() const { return m_tileWidth; } + + /** + * @return height in pixels of each sub-texture / tile + */ + uint16_t GetTileHeight() const { return m_tileHeight; } + +private: + void GenerateGrid(uint16_t tileWidth, uint16_t tileHeight, uint16_t tileBorder); + + uint16_t m_tileWidth; + uint16_t m_tileHeight; +}; + +#endif diff --git a/src/framework/graphics/image.cpp b/src/framework/graphics/image.cpp new file mode 100644 index 0000000..68e28ed --- /dev/null +++ b/src/framework/graphics/image.cpp @@ -0,0 +1,347 @@ +#include "../debug.h" +#include "../log.h" + +#include "image.h" + +#include "../file/file.h" +#include "../file/memoryfile.h" + +#include + +#define STBI_NO_STDIO +#include + +Image::Image() +{ + STACK_TRACE; + m_pixels = NULL; + m_width = 0; + m_height = 0; + m_bpp = 0; + m_format = IMAGE_FORMAT_NONE; + m_pitch = 0; +} + +Image::~Image() +{ + STACK_TRACE; + Release(); +} + +void Image::Release() +{ + STACK_TRACE; + SAFE_DELETE(m_pixels); + m_width = 0; + m_height = 0; + m_bpp = 0; + m_format = IMAGE_FORMAT_NONE; + m_pitch = 0; +} + + +BOOL Image::Create(uint16_t width, uint16_t height, IMAGE_FORMAT format) +{ + STACK_TRACE; + ASSERT(m_pixels == NULL); + if (m_pixels != NULL) + return FALSE; + + ASSERT(width != 0); + ASSERT(height != 0); + if (width == 0 || height == 0) + return FALSE; + + int bpp = 0; + if (format == IMAGE_FORMAT_RGB) + bpp = 24; + else if (format == IMAGE_FORMAT_RGBA) + bpp = 32; + else if (format == IMAGE_FORMAT_ALPHA) + bpp = 8; + + ASSERT(bpp != 0); + if (bpp == 0) + return FALSE; + + size_t pixelsLength = (width * height) * (bpp / 8); + m_pixels = new uint8_t[pixelsLength]; + memset(m_pixels, 0, pixelsLength); + + m_width = width; + m_height = height; + m_bpp = bpp; + m_format = format; + m_pitch = width * (bpp / 8); + + return TRUE; +} + +BOOL Image::Create(const Image *source) +{ + STACK_TRACE; + ASSERT(source != NULL); + if (source == NULL) + return FALSE; + else + return Create(source, 0, 0, source->GetWidth() - 1, source->GetHeight() - 1); +} + +BOOL Image::Create(const Image *source, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) +{ + STACK_TRACE; + ASSERT(m_pixels == NULL); + if (m_pixels != NULL) + return FALSE; + + ASSERT(source->GetPixels() != NULL); + if (source->GetPixels() == NULL) + return FALSE; + + ASSERT(right > left); + ASSERT(bottom > top); + ASSERT(left < source->GetWidth()); + ASSERT(right < source->GetWidth()); + ASSERT(top < source->GetHeight()); + ASSERT(bottom < source->GetHeight()); + + BOOL baseCreateSuccess = Create((right - left) + 1, (bottom - top) + 1, source->GetFormat()); + if (!baseCreateSuccess) + return FALSE; + + Copy(source, left, top, right, bottom, 0, 0); + + return TRUE; +} + +BOOL Image::Create(File *file) +{ + STACK_TRACE; + ASSERT(m_pixels == NULL); + if (m_pixels != NULL) + return FALSE; + + ASSERT(file != NULL); + if (file == NULL) + return FALSE; + + ASSERT(file->IsOpen()); + if (!file->IsOpen()) + return FALSE; + + uint8_t *imageFileBytes = NULL; + size_t imageFileSize = file->GetFileSize(); + + // if the file object is a MemoryFile, we can skip needing to allocate + copy memory around for stb_image + if (file->GetFileType() == FILETYPE_MEMORY) + { + MemoryFile *memoryFile = (MemoryFile*)file; + imageFileBytes = (uint8_t*)memoryFile->GetFileData(); + } + else + { + // load raw file bytes fully into memory (can't pass our File instance to stb_image) + imageFileBytes = new uint8_t[imageFileSize]; + ASSERT(imageFileBytes != NULL); + file->Read((int8_t*)imageFileBytes, imageFileSize); + } + + // load using stb_image + int width; + int height; + int componentsPerPixel; + uint8_t *pixels = stbi_load_from_memory(imageFileBytes, imageFileSize, &width, &height, &componentsPerPixel, 0); + if (pixels == NULL) + { + LOG_ERROR(LOGCAT_ASSETS, "Error loading image \"%s\": %s\n", file->GetFilename().c_str(), stbi_failure_reason()); + if (file->GetFileType() != FILETYPE_MEMORY) + SAFE_DELETE_ARRAY(imageFileBytes); + + return FALSE; + } + else + { + // don't need this anymore + if (file->GetFileType() != FILETYPE_MEMORY) + SAFE_DELETE_ARRAY(imageFileBytes); + + int bpp = componentsPerPixel * 8; + IMAGE_FORMAT format; + // TODO: detect IMAGE_FORMAT_ALPHA + if (componentsPerPixel == 3) + format = IMAGE_FORMAT_RGB; + else if (componentsPerPixel == 4) + format = IMAGE_FORMAT_RGBA; + else + { + ASSERT(!"Unrecognized componentsPerPixel value."); + stbi_image_free(pixels); + return FALSE; + } + + // copy from STB "owned" memory to our own, then free up the STB stuff + // (this is kind of unnecessary, but I'd like this method to be the + // *only* one that knows/cares about stb_image at all) + size_t pixelsLength = (width * height) * componentsPerPixel; + m_pixels = new uint8_t[pixelsLength]; + memcpy(m_pixels, pixels, pixelsLength); + stbi_image_free(pixels); + + m_width = width; + m_height = height; + m_bpp = bpp; + m_format = format; + m_pitch = width * componentsPerPixel; + + return TRUE; + } +} + +Color Image::GetColor(uint16_t x, uint16_t y) const +{ + STACK_TRACE; + ASSERT(m_format == IMAGE_FORMAT_RGB || m_format == IMAGE_FORMAT_RGBA); + + if (m_format == IMAGE_FORMAT_RGB) + { + uint8_t *pixel = Get(x, y); + return Color(*pixel, *(pixel + 1), *(pixel + 2)); + } + else + { + uint8_t *pixel = Get(x, y); + return Color(*pixel, *(pixel + 1), *(pixel + 2), *(pixel + 3)); + } +} + +void Image::SetColor(uint16_t x, uint16_t y, const Color &color) +{ + STACK_TRACE; + ASSERT(m_format == IMAGE_FORMAT_RGB || m_format == IMAGE_FORMAT_RGBA); + + if (m_format == IMAGE_FORMAT_RGB) + { + uint8_t *pixel = Get(x, y); + uint8_t dummy; + color.ToInts(pixel, pixel + 1, pixel + 2, &dummy); + } + else + { + uint8_t *pixel = Get(x, y); + color.ToInts(pixel, pixel + 1, pixel + 2, pixel + 3); + } +} + +void Image::Copy(const Image *source, uint16_t destX, uint16_t destY) +{ + STACK_TRACE; + ASSERT(source != NULL); + Copy(source, 0, 0, source->GetWidth() - 1, source->GetHeight() - 1, destX, destY); +} + +void Image::Copy(const Image *source, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom, uint16_t destX, uint16_t destY) +{ + STACK_TRACE; + ASSERT(source != NULL); + ASSERT(source->GetBpp() == m_bpp); + ASSERT(right > left); + ASSERT(bottom > top); + ASSERT(left < source->GetWidth()); + ASSERT(right < source->GetWidth()); + ASSERT(top < source->GetHeight()); + ASSERT(bottom < source->GetHeight()); + ASSERT(destX < m_width); + ASSERT(destY < m_height); + ASSERT((right - left) < m_width); + ASSERT((bottom - top) < m_height); + ASSERT(destX + (right - left) < m_width); + ASSERT(destY + (bottom - top) < m_height); + + uint8_t *sourcePixels = source->GetPixels() + source->GetOffsetFor(left, top); + uint8_t *destPixels = m_pixels + GetOffsetFor(destX, destY); + + size_t lineWidthInBytes = ((right - left) + 1) * (m_bpp / 8); + uint16_t numLinesToCopy = (bottom - top) + 1; + + for (uint16_t i = 0; i < numLinesToCopy; ++i) + { + memcpy(destPixels, sourcePixels, lineWidthInBytes); + sourcePixels += source->GetPitch(); + destPixels += m_pitch; + } +} + +void Image::Clear() +{ + STACK_TRACE; + memset(m_pixels, 0, GetSizeInBytes()); +} + +void Image::Clear(const Color &color) +{ + STACK_TRACE; + ASSERT(m_format == IMAGE_FORMAT_RGB || m_format == IMAGE_FORMAT_RGBA); + + uint32_t sizeInBytes = GetSizeInBytes(); + uint8_t *pixel = m_pixels; + + if (m_format == IMAGE_FORMAT_RGB) + { + ASSERT(sizeInBytes % 3 == 0); + uint8_t dummy; + for (uint32_t i = 0; i < sizeInBytes; i += 3) + { + color.ToInts(pixel, pixel + 1, pixel + 2, &dummy); + pixel += 3; + } + } + else + { + ASSERT(sizeInBytes % 4 == 0); + for (uint32_t i = 0; i < sizeInBytes; i += 4) + { + color.ToInts(pixel, pixel + 1, pixel + 2, pixel + 3); + pixel += 4; + } + } +} + +void Image::Clear(const uint32_t color) +{ + STACK_TRACE; + Clear(Color::FromInt(color)); +} + +void Image::Clear(const uint8_t alpha) +{ + STACK_TRACE; + ASSERT(m_format == IMAGE_FORMAT_ALPHA); + memset(m_pixels, alpha, GetSizeInBytes()); +} + +void Image::FlipVertically() +{ + STACK_TRACE; + ASSERT(m_pixels != NULL); + if (m_pixels == NULL) + return; + + // TODO: this is a naive implementation. fix so it can flip the image + // one scanline at a time using the already allocated memory + + size_t pixelsLength = (m_width * m_height) * (m_bpp / 8); + uint8_t *flippedPixels = new uint8_t[pixelsLength]; + + uint8_t *source = (m_pixels + pixelsLength) - m_pitch; // first pixel of the last line + uint8_t *dest = flippedPixels; // first pixel of the first line + + for (uint16_t y = 0; y < m_height; ++y) + { + memcpy(dest, source, m_pitch); + source -= m_pitch; // go up one line + dest += m_pitch; // go down one line + } + + SAFE_DELETE(m_pixels); + m_pixels = flippedPixels; +} diff --git a/src/framework/graphics/image.h b/src/framework/graphics/image.h new file mode 100644 index 0000000..f0759b6 --- /dev/null +++ b/src/framework/graphics/image.h @@ -0,0 +1,221 @@ +#ifndef __FRAMEWORK_GRAPHICS_IMAGE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_IMAGE_H_INCLUDED__ + +#include "../common.h" +#include "../content/content.h" + +#include "color.h" +#include "imageformats.h" + +class File; + +/** + * Represents raw 2D image data. + */ +class Image : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "Image"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + Image(); + virtual ~Image(); + + /** + * Creates a empty new image. + * @param width the width of the image + * @param height the height of the image + * @param format the pixel format of the image + * @return TRUE if successful + */ + BOOL Create(uint16_t width, uint16_t height, IMAGE_FORMAT format); + + /** + * Creates a copy of an image from another image object. + * @param source the source image object to copy + * @return TRUE if successful + */ + BOOL Create(const Image *source); + + /** + * Creates a copy of a subsection of an image. + * @param source the source image object to copy + * @param left left X coordinate of the source region to copy + * @param top top Y coordinate of the source region to copy + * @param right right X coordinate of the source region to copy + * @param bottom bottom Y coordinate of the source region to copy + * @return TRUE if successful + */ + BOOL Create(const Image *source, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom); + + /** + * Creates an image from an image file. + * @param file the file to load as an image + * @return TRUE if successful + */ + BOOL Create(File *file); + + /** + * Frees all image resources. + */ + void Release(); + + /** + * @return pointer to raw image pixel data + */ + uint8_t* GetPixels() const { return m_pixels; } + + /** + * @return offset into the raw image pixel data that corresponds + * to the given X and Y coordinate on the image + */ + uint32_t GetOffsetFor(uint16_t x, uint16_t y) const; + + /** + * Gets a pointer to the raw image pixel data beginning at the given + * X and Y coordinates on the image. + * @param x X coordinate to get a pointer to + * @param y Y coordinate to get a pointer to + * @return pointer to the raw image pixel data for this location + */ + uint8_t* Get(uint16_t x, uint16_t y) const; + + /** + * Gets a filled color object that corresponds to the pixel located + * at the given image position. + * @param x X coordinate to get the color of + * @param y Y coordinate to get the color of + * @return color object containing the color of the specified pixel + */ + Color GetColor(uint16_t x, uint16_t y) const; + + /** + * Sets the color of a pixel on the image. + * @param x X coordinate of the pixel to set + * @param y Y coordinate of the pixel to set + * @param color the color to set the pixel to + */ + void SetColor(uint16_t x, uint16_t y, const Color &color); + + /** + * Sets the color of a pixel on the image. + * @param x X coordinate of the pixel to set + * @param y Y coordinate of the pixel to set + * @param color the color (as a 32-bit hex value) to set the pixel to + */ + void SetColor(uint16_t x, uint16_t y, uint32_t color) { SetColor(x, y, Color::FromInt(color)); } + + /** + * Copies a source image and draws it onto this image at the position + * given. The source image must fit entirely in this image. No clipping + * is performed. + * @param source the source image to copy + * @param destX the X coordinate to copy the source image to on this image + * @param destY the Y coordinate to copy the source image to on this image + */ + void Copy(const Image *source, uint16_t destX, uint16_t destY); + + /** + * Copies a source image and draws it onto this image at the position + * given. The source image must fit entirely in this image. No clipping + * is performed. + * @param source the source image to copy + * @param left the left X coordinate of the region to copy from the source image + * @param top the top Y coordinate of the region to copy from the source image + * @param right the right X coordinate of the region to copy from the source image + * @param bottom the bottom Y coordinate of the region to copy from the source image + * @param destX the X coordinate to copy the source image to on this image + * @param destY the Y coordinate to copy the source image to on this image + */ + void Copy(const Image *source, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom, uint16_t destX, uint16_t destY); + + /** + * @return the width of this image + */ + uint16_t GetWidth() const { return m_width; } + + /** + * @return the height of this image + */ + uint16_t GetHeight() const { return m_height; } + + /** + * @return the bits per pixel of this image's pixel data + */ + uint8_t GetBpp() const { return m_bpp; } + + /** + * @return the pixel format of this image + */ + IMAGE_FORMAT GetFormat() const { return m_format; } + + /** + * @return the number of bytes equivalent to one horizontal line + * of pixel data + */ + uint32_t GetPitch() const { return m_pitch; } + + /** + * @return the number of bytes the raw pixel data in this image + */ + uint32_t GetSizeInBytes() const; + + /** + * Zeros-out the pixel data for this image. + */ + void Clear(); + + /** + * Clears the image using the given color. + * @param color the color to clear the image with + */ + void Clear(const Color &color); + + /** + * Clears the image using the given color. + * @param color the color (as a 32-bit hex value) to clear the image with + */ + void Clear(const uint32_t color); + + /** + * Clears the image using the given alpha value. This can only be + * used with images where the format is IMAGE_FORMAT_ALPHA. + * @param alpha the alpha value to clear the image with + */ + void Clear(const uint8_t alpha); + + /** + * Flips the image vertically. + */ + void FlipVertically(); + +private: + uint8_t *m_pixels; + uint32_t m_pitch; + uint16_t m_width; + uint16_t m_height; + uint8_t m_bpp; + IMAGE_FORMAT m_format; +}; + +inline uint32_t Image::GetOffsetFor(uint16_t x, uint16_t y) const +{ + return (x + (y * m_width)) * (m_bpp / 8); +} + +inline uint8_t* Image::Get(uint16_t x, uint16_t y) const +{ + return m_pixels + GetOffsetFor(x, y); +} + +inline uint32_t Image::GetSizeInBytes() const +{ + return (m_width * m_height) * (m_bpp / 8); +} + +#endif + diff --git a/src/framework/graphics/imageformats.h b/src/framework/graphics/imageformats.h new file mode 100644 index 0000000..5ccb007 --- /dev/null +++ b/src/framework/graphics/imageformats.h @@ -0,0 +1,15 @@ +#ifndef __FRAMEWORK_GRAPHICS_IMAGEFORMATS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_IMAGEFORMATS_H_INCLUDED__ + +/** + * Constant values to refer to different kinds of image pixel formats. + */ +enum IMAGE_FORMAT +{ + IMAGE_FORMAT_NONE = 0, + IMAGE_FORMAT_RGB = 3, + IMAGE_FORMAT_RGBA = 4, + IMAGE_FORMAT_ALPHA = 1 +}; + +#endif diff --git a/src/framework/graphics/indexbuffer.cpp b/src/framework/graphics/indexbuffer.cpp new file mode 100644 index 0000000..b372b79 --- /dev/null +++ b/src/framework/graphics/indexbuffer.cpp @@ -0,0 +1,57 @@ +#include "../debug.h" + +#include "indexbuffer.h" + +#include + +IndexBuffer::IndexBuffer(uint32_t numIndices, BOOL isStatic) + : BufferObject(BUFFEROBJECT_TYPE_INDEX, isStatic ? BUFFEROBJECT_USAGE_STATIC : BUFFEROBJECT_USAGE_DYNAMIC) +{ + STACK_TRACE; + m_currentIndex = 0; + Resize(numIndices); +} + +IndexBuffer::IndexBuffer(const IndexBuffer *source) + : BufferObject(BUFFEROBJECT_TYPE_INDEX, source->GetUsage()) +{ + STACK_TRACE; + ASSERT(source != NULL); + ASSERT(source->GetNumElements() > 0); + + m_currentIndex = 0; + Resize(source->GetNumElements()); + + memcpy(&m_buffer[0], source->GetBuffer(), GetNumElements() * GetElementWidthInBytes()); +} + +IndexBuffer::~IndexBuffer() +{ + STACK_TRACE; +} + +void IndexBuffer::Set(const uint16_t *indices, uint32_t numIndices) +{ + STACK_TRACE; + memcpy(&m_buffer[0], indices, GetNumElements() * GetElementWidthInBytes()); +} + +void IndexBuffer::Resize(uint32_t numIndices) +{ + STACK_TRACE; + m_buffer.resize(numIndices, 0); + + if (!IsClientSideBuffer()) + SizeBufferObject(); + + if (m_currentIndex >= GetNumElements()) + --m_currentIndex; +} + +void IndexBuffer::Extend(uint32_t amount) +{ + STACK_TRACE; + uint32_t newSize = GetNumElements() + amount; + Resize(newSize); +} + diff --git a/src/framework/graphics/indexbuffer.h b/src/framework/graphics/indexbuffer.h new file mode 100644 index 0000000..1cab64a --- /dev/null +++ b/src/framework/graphics/indexbuffer.h @@ -0,0 +1,178 @@ +#ifndef __FRAMEWORK_GRAPHICS_INDEXBUFFER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_INDEXBUFFER_H_INCLUDED__ + +#include "../common.h" +#include "bufferobject.h" + +#include // for abs() +#include + +/** + * Wraps management of an array of vertex indexes to be used for + * optimized rendering of vertices. + */ +class IndexBuffer : public BufferObject +{ +public: + /** + * Creates an index buffer. + * @param numIndices the initial number of indices the buffer should hold + * @param isStatic whether the index data is static or dynamic (used as + * a hint for index data stored in video memory) + */ + IndexBuffer(uint32_t numIndices, BOOL isStatic); + + /** + * Creates an index buffer. + * @param source the source buffer to copy during creation of this buffer + */ + IndexBuffer(const IndexBuffer *source); + + virtual ~IndexBuffer(); + + /** + * Copies the source indices over top of this buffer's existing indices. + * @param indices the source index data to copy + * @param numIndices the number of indices to copy from the source + */ + void Set(const uint16_t *indices, uint32_t numIndices); + + /** + * Sets an index to a new value. + * @param index the position of the index in this buffer to set + * @param value the new value to set + */ + void SetIndex(uint32_t index, uint16_t value); + + /** + * Moves the current index position to the next position. + * @return TRUE if the move succeeded, FALSE if there is no more indices + * to move to after this one + */ + BOOL MoveNext(); + + /** + * Moves the current index position to the previous position. + * @return TRUE if the move succeeded, FALSE if there is no more indices + * to move to before the current one + */ + BOOL MovePrevious(); + + /** + * Moves the current index position by the specified amount relative + * to the current position. + * @param numIndices the number of indices to move. If this amount is + * greater then the remaining space left in the same + * direction, then it will be shrunk so as not to move + * out of bounds. + */ + void Move(int32_t numIndices); + + /** + * Moves the current index position to the beginning of the buffer. + */ + void MoveToStart() { m_currentIndex = 0; } + + /** + * Moves the current index position to the end of the buffer. + */ + void MoveToEnd() { m_currentIndex = GetNumElements() - 1; } + + /** + * Moves the current index position to the position specified. + * @param index the position to move to + */ + void MoveTo(uint32_t index) { m_currentIndex = index; } + + /** + * Sets the index at the current position to a new value. + * @param index the new value to set + */ + void SetCurrent(uint16_t index) { SetIndex(m_currentIndex, index); } + + /** + * Resizes the buffer capacity to hold the specified number of indices. + * @param numIndices the amount of indices the buffer should be resized + * to hold + */ + void Resize(uint32_t numIndices); + + /** + * Extends the buffer capacity to hold the specified number of extra indices. + * @param amount the amount of indices to extend the buffer by + */ + void Extend(uint32_t amount); + + /** + * @return the number of indices contained in this buffer + */ + uint32_t GetNumElements() const { return m_buffer.size(); } + + /** + * @return the size in bytes of each index in this buffer object + */ + size_t GetElementWidthInBytes() const { return sizeof(uint16_t); } + + /** + * @return pointer to this buffer object's raw data + */ + const void* GetBuffer() const { return &m_buffer[0]; } + + /** + * @return the current position in the buffer + */ + uint32_t GetCurrentPosition() const { return m_currentIndex; } + + /** + * @return the number of index spaces left between the current position + * and the end of the buffer + */ + uint32_t GetRemainingSpace() const { return (GetNumElements() - 1) - GetCurrentPosition(); } + +private: + stl::vector m_buffer; + + uint32_t m_currentIndex; +}; + +inline void IndexBuffer::SetIndex(uint32_t index, uint16_t value) +{ + m_buffer[index] = value; +} + +inline BOOL IndexBuffer::MoveNext() +{ + ++m_currentIndex; + if (m_currentIndex >= GetNumElements()) + { + --m_currentIndex; + return FALSE; + } + else + return TRUE; +} + +inline BOOL IndexBuffer::MovePrevious() +{ + if (m_currentIndex == 0) + return FALSE; + else + { + --m_currentIndex; + return TRUE; + } +} + +inline void IndexBuffer::Move(int32_t numIndices) +{ + // m_currentIndex is unsigned, so detect when we would go negative beforehand + if (numIndices < 0 && (uint32_t)abs(numIndices) > m_currentIndex) + m_currentIndex = 0; + else + { + m_currentIndex += numIndices; + if (m_currentIndex >= GetNumElements()) + m_currentIndex = GetNumElements() - 1; + } +} +#endif diff --git a/src/framework/graphics/renderbuffer.cpp b/src/framework/graphics/renderbuffer.cpp new file mode 100644 index 0000000..202a315 --- /dev/null +++ b/src/framework/graphics/renderbuffer.cpp @@ -0,0 +1,120 @@ +#include "../debug.h" + +#include "../common.h" +#include "renderbuffer.h" +#include "glincludes.h" +#include "glutils.h" +#include "graphicsdevice.h" +#include "../math/mathhelpers.h" + +Renderbuffer::Renderbuffer() +{ + STACK_TRACE; + m_renderbufferName = 0; + m_width = 0; + m_height = 0; + m_type = FRAMEBUFFER_DATA_NONE; +} + +Renderbuffer::~Renderbuffer() +{ + STACK_TRACE; + Release(); +} + +BOOL Renderbuffer::Create(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height, FRAMEBUFFER_DATA_TYPE type) +{ + STACK_TRACE; + ASSERT(m_renderbufferName == 0); + if (m_renderbufferName != 0) + return FALSE; + + ASSERT(graphicsDevice != NULL); + + uint32_t format = 0; +#ifdef MOBILE + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + format = GL_RGB565; + break; + case FRAMEBUFFER_DATA_COLOR_RGBA: + format = GL_RGBA4; + break; + case FRAMEBUFFER_DATA_DEPTH: + format = GL_DEPTH_COMPONENT16; + break; + case FRAMEBUFFER_DATA_STENCIL: + format = GL_STENCIL_INDEX8; + default: break; + }; +#else + switch (type) + { + case FRAMEBUFFER_DATA_COLOR_RGB: + format = GL_RGB; + break; + case FRAMEBUFFER_DATA_COLOR_RGBA: + format = GL_RGBA; + break; + case FRAMEBUFFER_DATA_DEPTH: + format = GL_DEPTH_COMPONENT; + break; + case FRAMEBUFFER_DATA_STENCIL: + format = GL_STENCIL_INDEX; + break; + default: break; + }; +#endif + ASSERT(format != 0); + if (format == 0) + return FALSE; + + GL_CALL(glGenRenderbuffers(1, &m_renderbufferName)); + + m_width = width; + m_height = height; + m_type = type; + + m_graphicsDevice->BindRenderbuffer(this); + + // have OpenGL allocate the renderbuffer's storage + GL_CALL(glRenderbufferStorage(GL_RENDERBUFFER, format, width, height)); + + // don't leave this buffer bound, we'll let an associated Framebuffer + // object that this will get attached to manage that for itself... + m_graphicsDevice->UnbindRenderbuffer(); + + return TRUE; +} + +void Renderbuffer::Release() +{ + STACK_TRACE; + if (m_renderbufferName != 0) + { + m_graphicsDevice->UnbindRenderBuffer(this); + GL_CALL(glDeleteRenderbuffers(1, &m_renderbufferName)); + } + + m_graphicsDevice = NULL; + m_renderbufferName = 0; + m_width = 0; + m_height = 0; +} + +void Renderbuffer::OnNewContext() +{ + STACK_TRACE; + if (m_renderbufferName == 0 && m_graphicsDevice != NULL) + { + BOOL success = Create(m_graphicsDevice, m_width, m_height, m_type); + ASSERT(success == TRUE); + } +} + +void Renderbuffer::OnLostContext() +{ + STACK_TRACE; + m_renderbufferName = 0; +} diff --git a/src/framework/graphics/renderbuffer.h b/src/framework/graphics/renderbuffer.h new file mode 100644 index 0000000..4f05e3b --- /dev/null +++ b/src/framework/graphics/renderbuffer.h @@ -0,0 +1,79 @@ +#ifndef __FRAMEWORK_GRAPHICS_RENDERBUFFER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_RENDERBUFFER_H_INCLUDED__ + +#include "../common.h" +#include "framebufferdatatypes.h" +#include "graphicscontextresource.h" + +class GraphicsDevice; + +/** + * Represents a renderbuffer that stores off-screen image data for a + * framebuffer object. + */ +class Renderbuffer : public GraphicsContextResource +{ +public: + Renderbuffer(); + virtual ~Renderbuffer(); + + /** + * Creates a new renderbuffer with the specified properties. + * @param graphicsDevice this graphics device this renderbuffer is + * associated with + * @param width the width of the renderbuffer in pixels + * @param height the height of the renderbuffer in pixels + * @param format the type of data this renderbuffer contains + * @return TRUE if the renderbuffer was created successfully + */ + BOOL Create(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height, FRAMEBUFFER_DATA_TYPE type); + + /** + * Releases the resources associated with this renderbuffer. + */ + void Release(); + + /** + * @return the name or ID assigned to this renderbuffer by OpenGL + */ + uint32_t GetRenderbufferName() const { return m_renderbufferName; } + + /** + * @return the width of the renderbuffer in pixels + */ + uint16_t GetWidth() const { return m_width; } + + /** + * @return the height of the renderbuffer in pixels + */ + uint16_t GetHeight() const { return m_height; } + + /** + * @return the type of data this renderbuffer contains + */ + FRAMEBUFFER_DATA_TYPE GetType() const { return m_type; } + + /** + * @return TRUE if the renderbuffer has been marked as invalid and needs to be recreated + */ + BOOL IsInvalidated() const { return m_renderbufferName == 0; } + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + +private: + GraphicsDevice *m_graphicsDevice; + uint32_t m_renderbufferName; + uint16_t m_width; + uint16_t m_height; + FRAMEBUFFER_DATA_TYPE m_type; +}; + +#endif diff --git a/src/framework/graphics/renderstate.cpp b/src/framework/graphics/renderstate.cpp new file mode 100644 index 0000000..2f66e9b --- /dev/null +++ b/src/framework/graphics/renderstate.cpp @@ -0,0 +1,83 @@ +#include "../debug.h" + +#include "renderstate.h" + +#include "glincludes.h" +#include "glutils.h" + +RenderState::RenderState() +{ + STACK_TRACE; + Initialize(); +} + +RenderState::~RenderState() +{ + STACK_TRACE; +} + +void RenderState::Initialize() +{ + STACK_TRACE; + m_depthTesting = TRUE; + m_depthFunction = DEPTH_LESS; + m_faceCulling = TRUE; + m_faceCullingMode = BACK; + m_lineWidth = 1.0f; +} + +void RenderState::Apply() const +{ + STACK_TRACE; + if (m_depthTesting) + { + GL_CALL(glEnable(GL_DEPTH_TEST)); + GL_CALL(glDepthFunc(FindDepthFunctionValue(m_depthFunction))); + } + else + { + GL_CALL(glDisable(GL_DEPTH_TEST)); + } + + SetFaceCulling(); + + GL_CALL(glLineWidth(m_lineWidth)); +} + +void RenderState::SetFaceCulling() const +{ + STACK_TRACE; + if (m_faceCulling) + { + GL_CALL(glEnable(GL_CULL_FACE)); + switch (m_faceCullingMode) + { + case FRONT_AND_BACK: + GL_CALL(glCullFace(GL_FRONT_AND_BACK)); + break; + case FRONT: + GL_CALL(glCullFace(GL_FRONT)); + break; + default: + GL_CALL(glCullFace(GL_BACK)); + break; + } + } + else + GL_CALL(glDisable(GL_CULL_FACE)); +} + +int RenderState::FindDepthFunctionValue(DEPTH_FUNCTION function) const +{ + switch (function) + { + case DEPTH_NEVER: return GL_NEVER; + case DEPTH_LESS: return GL_LESS; + case DEPTH_EQUAL: return GL_EQUAL; + case DEPTH_LESS_OR_EQUAL: return GL_LEQUAL; + case DEPTH_GREATER: return GL_GREATER; + case DEPTH_NOT_EQUAL: return GL_NOTEQUAL; + case DEPTH_GREATER_OR_EQUAL: return GL_GEQUAL; + default: return GL_ALWAYS; + } +} diff --git a/src/framework/graphics/renderstate.h b/src/framework/graphics/renderstate.h new file mode 100644 index 0000000..d8da13c --- /dev/null +++ b/src/framework/graphics/renderstate.h @@ -0,0 +1,109 @@ +#ifndef __FRAMEWORK_GRAPHICS_RENDERSTATE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_RENDERSTATE_H_INCLUDED__ + +#include "../common.h" + +enum CULL_MODE +{ + BACK, + FRONT, + FRONT_AND_BACK +}; + +enum DEPTH_FUNCTION +{ + DEPTH_NEVER, + DEPTH_LESS, + DEPTH_EQUAL, + DEPTH_LESS_OR_EQUAL, + DEPTH_GREATER, + DEPTH_NOT_EQUAL, + DEPTH_GREATER_OR_EQUAL, + DEPTH_ALWAYS +}; + +/** + * Wraps render settings for OpenGL. Instances of this class can be initialized + * and then used later on during execution to quickly apply a set of render states. + */ +class RenderState +{ +public: + /** + * Creates a new render state object with default settings matching OpenGL's + * initial settings. + */ + RenderState(); + + virtual ~RenderState(); + + /** + * Applies render states to the current OpenGL context. + */ + void Apply() const; + + /** + * @return TRUE if depth testing is enabled + */ + BOOL GetDepthTesting() const { return m_depthTesting; } + + /** + * @return the depth testing function + */ + DEPTH_FUNCTION GetDepthFunction() const { return m_depthFunction; } + + /** + * @return TRUE if polygons are being culled based on their vertices winding + */ + BOOL GetFaceCulling() const { return m_faceCulling; } + + /** + * @return the polygon cull mode + */ + CULL_MODE GetFaceCullingMode() const { return m_faceCullingMode; } + + /** + * @return the width of rasterized lines + */ + float GetLineWidth() const { return m_lineWidth; } + + /** + * Toggles depth testing on/off. + */ + void SetDepthTesting(BOOL enable) { m_depthTesting = enable; } + + /** + * Sets the depth testing function. + */ + void SetDepthFunction(DEPTH_FUNCTION function) { m_depthFunction = function; } + + /** + * Toggles polygon culling based on their vertices winding on/off. + */ + void SetFaceCulling(BOOL enable) { m_faceCulling = enable; } + + /** + * Sets the polygon culling mode. + */ + void SetFaceCullingMode(CULL_MODE mode) { m_faceCullingMode = mode; } + + /** + * Sets the width of rasterized lines. + */ + void SetLineWidth(float width) { m_lineWidth = width; } + +private: + void Initialize(); + void SetFaceCulling() const; + int FindDepthFunctionValue(DEPTH_FUNCTION function) const; + + BOOL m_depthTesting; + DEPTH_FUNCTION m_depthFunction; + BOOL m_faceCulling; + CULL_MODE m_faceCullingMode; + float m_lineWidth; +}; + +#define RENDERSTATE_DEFAULT RenderState() + +#endif diff --git a/src/framework/graphics/shader.cpp b/src/framework/graphics/shader.cpp new file mode 100644 index 0000000..c0dfb73 --- /dev/null +++ b/src/framework/graphics/shader.cpp @@ -0,0 +1,1095 @@ +#include "../debug.h" +#include "../log.h" + +#include "shader.h" +#include "color.h" +#include "glincludes.h" +#include "glutils.h" +#include "../math/matrix3x3.h" +#include "../math/matrix4x4.h" +#include "../math/point2.h" +#include "../math/point3.h" +#include "../math/quaternion.h" +#include "../math/vector2.h" +#include "../math/vector3.h" +#include "../math/vector4.h" +#include "../support/text.h" +#include + +// HACK: ensure these are all the sizes we expect without any compiler-added +// alignment padding. some Shader::SetUniform() calls do memcpy's assuming +// contiguous memory in arrays of these structs so this is very important! +// (I have no idea if any of these asserts would ever not pass. Each of +// these structs contains _only_ member variables each 4 bytes in size.) +STATIC_ASSERT(sizeof(Vector2) == 2 * sizeof(float)); +STATIC_ASSERT(sizeof(Vector3) == 3 * sizeof(float)); +STATIC_ASSERT(sizeof(Vector4) == 4 * sizeof(float)); +STATIC_ASSERT(sizeof(Quaternion) == 4 * sizeof(float)); +STATIC_ASSERT(sizeof(Matrix3x3) == 9 * sizeof(float)); +STATIC_ASSERT(sizeof(Matrix4x4) == 16 * sizeof(float)); +STATIC_ASSERT(sizeof(Point2) == 2 * sizeof(int32_t)); +STATIC_ASSERT(sizeof(Point3) == 3 * sizeof(int32_t)); + +Shader::Shader() +{ + STACK_TRACE; + Initialize(); +} + +Shader::Shader(const char *vertexShaderSource, const char *fragmentShaderSource) +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + Initialize(); + LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); + CacheShaderSources(vertexShaderSource, fragmentShaderSource); +} + +Shader::Shader(const Text *vertexShaderSource, const Text *fragmentShaderSource) +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(vertexShaderSource->GetLength() > 0); + ASSERT(fragmentShaderSource != NULL); + ASSERT(fragmentShaderSource->GetLength() > 0); + + Initialize(); + LoadCompileAndLink(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); + CacheShaderSources(vertexShaderSource->GetText(), fragmentShaderSource->GetText()); +} + +Shader::~Shader() +{ + STACK_TRACE; + if (m_vertexShaderId) + { + GL_CALL(glDeleteShader(m_vertexShaderId)); + } + if (m_fragmentShaderId) + { + GL_CALL(glDeleteShader(m_fragmentShaderId)); + } + if (m_programId) + { + GL_CALL(glDeleteProgram(m_programId)); + } + + SAFE_DELETE_ARRAY(m_attributeMapping); + + // if these were pointing to the same string, we obviously should only + // delete once... + if (m_cachedVertexShaderSource == m_cachedFragmentShaderSource) + { + SAFE_DELETE_ARRAY(m_cachedVertexShaderSource); + m_cachedFragmentShaderSource = NULL; + } + else + { + SAFE_DELETE_ARRAY(m_cachedVertexShaderSource); + SAFE_DELETE_ARRAY(m_cachedFragmentShaderSource); + } +} + +void Shader::Initialize() +{ + STACK_TRACE; + m_isBound = FALSE; + m_cachedVertexShaderSource = NULL; + m_cachedFragmentShaderSource = NULL; + m_vertexShaderCompileStatus = FALSE; + m_fragmentShaderCompileStatus = FALSE; + m_linkStatus = FALSE; + m_vertexShaderId = 0; + m_fragmentShaderId = 0; + m_programId = 0; + m_attributeMapping = NULL; + m_numAttributes = 0; + +} + +BOOL Shader::LoadCompileAndLink(const char *vertexShaderSource, const char *fragmentShaderSource) +{ + STACK_TRACE; + const char *vertexShaderToLoad = vertexShaderSource; + const char *fragmentShaderToLoad = fragmentShaderSource; + + // if no source was provided, see if there is some cached source to load instead + if (vertexShaderToLoad == NULL) + vertexShaderToLoad = m_cachedVertexShaderSource; + if (fragmentShaderToLoad == NULL) + fragmentShaderToLoad = m_cachedFragmentShaderSource; + + // must have *some* kind of source to load at any rate... + ASSERT(vertexShaderToLoad != NULL); + ASSERT(fragmentShaderToLoad != NULL); + + if (!Compile(vertexShaderToLoad, fragmentShaderToLoad)) + return FALSE; + + if (!Link()) + return FALSE; + + LoadUniformInfo(); + LoadAttributeInfo(); + + return TRUE; +} + +BOOL Shader::ReloadCompileAndLink(const char *vertexShaderSource, const char *fragmentShaderSource) +{ + STACK_TRACE; + // clear out data that will be reset during the reload first + m_isBound = FALSE; + m_vertexShaderCompileStatus = FALSE; + m_fragmentShaderCompileStatus = FALSE; + m_linkStatus = FALSE; + m_vertexShaderId = 0; + m_fragmentShaderId = 0; + m_programId = 0; + m_uniforms.clear(); + m_attributes.clear(); + m_cachedUniforms.clear(); + + // TODO: leaving the attribute type mappings intact. This could maybe be a problem? + // I think only if the attribute ID's can be assigned randomly by OpenGL even if + // the source remains the same each time would it ever be a problem to keep the + // old type mappings intact. Since OpenGL assigns the attribute index a zero-based + // number I have a feeling it is based on the declaration order in the shader + // source... so as long as the source doesn't change it should be the same + + // then load + compile/link + return LoadCompileAndLink(vertexShaderSource, fragmentShaderSource); +} + +void Shader::CacheShaderSources(const char *vertexShaderSource, const char *fragmentShaderSource) +{ + STACK_TRACE; + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + // we reallocate cache buffers if they already have source in them + // (who knows, this may come in handy later for dynamic reloading of modified + // shader source files ... ?) + + size_t vertexSourceLength = strlen(vertexShaderSource); + SAFE_DELETE_ARRAY(m_cachedVertexShaderSource); + m_cachedVertexShaderSource = new char[vertexSourceLength + 1]; + memcpy(m_cachedVertexShaderSource, vertexShaderSource, vertexSourceLength + 1); + + // if the given source buffers point to the same location, then we don't + // need to allocate 2 cache buffers (they are the same string!). so just + // copy the vertex source cache pointer and reuse + if (vertexShaderSource == fragmentShaderSource) + m_cachedFragmentShaderSource = m_cachedVertexShaderSource; + else + { + size_t fragmentSourceLength = strlen(fragmentShaderSource); + SAFE_DELETE_ARRAY(m_cachedFragmentShaderSource); + m_cachedFragmentShaderSource = new char[fragmentSourceLength + 1]; + memcpy(m_cachedFragmentShaderSource, fragmentShaderSource, fragmentSourceLength + 1); + } +} + +BOOL Shader::Compile(const char *vertexShaderSource, const char *fragmentShaderSource) +{ + STACK_TRACE; + ASSERT(m_vertexShaderId == 0); + ASSERT(m_fragmentShaderId == 0); + ASSERT(m_programId == 0); + ASSERT(vertexShaderSource != NULL); + ASSERT(fragmentShaderSource != NULL); + + // load and compile the vertex shader first... + GL_CALL(m_vertexShaderId = glCreateShader(GL_VERTEX_SHADER)); + ASSERT(m_vertexShaderId != 0); + + // add in a special #define for convenience when we want to put both + // vertex and fragment shaders in the same source file + const char *vertexSources[2] = { "#define VERTEX\n", vertexShaderSource }; + GLint vertexSourcesLength[2]; + vertexSourcesLength[0] = strlen(vertexSources[0]); + vertexSourcesLength[1] = strlen(vertexSources[1]); + GL_CALL(glShaderSource(m_vertexShaderId, 2, vertexSources, vertexSourcesLength)); + + GL_CALL(glCompileShader(m_vertexShaderId)); + GL_CALL(glGetShaderiv(m_vertexShaderId, GL_COMPILE_STATUS, &m_vertexShaderCompileStatus)); + + // log compiler errors + if (!m_vertexShaderCompileStatus) + { + GLint logLength = 0; + GL_CALL(glGetShaderiv(m_vertexShaderId, GL_INFO_LOG_LENGTH, &logLength)); + if (logLength > 1) + { + char *infoLog = new char[logLength]; + ASSERT(infoLog != NULL); + + GLsizei infoLogLength = 0; + GL_CALL(glGetShaderInfoLog(m_vertexShaderId, logLength, &infoLogLength, infoLog)); + LOG_ERROR(LOGCAT_OPENGL, "Error compiling vertex shader:\n%s\n", infoLog); + + SAFE_DELETE(infoLog); + } + } + + // ... and the fragment shader next + GL_CALL(m_fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER)); + ASSERT(m_fragmentShaderId != 0); + + // add in a special #define for convenience when we want to put both + // vertex and fragment shaders in the same source file + const char *fragmentSources[2] = { "#define FRAGMENT\n", fragmentShaderSource }; + GLint fragmentSourcesLength[2]; + fragmentSourcesLength[0] = strlen(fragmentSources[0]); + fragmentSourcesLength[1] = strlen(fragmentSources[1]); + GL_CALL(glShaderSource(m_fragmentShaderId, 2, fragmentSources, fragmentSourcesLength)); + + GL_CALL(glCompileShader(m_fragmentShaderId)); + GL_CALL(glGetShaderiv(m_fragmentShaderId, GL_COMPILE_STATUS, &m_fragmentShaderCompileStatus)); + + // log compiler errors + if (!m_fragmentShaderCompileStatus) + { + GLint logLength = 0; + GL_CALL(glGetShaderiv(m_fragmentShaderId, GL_INFO_LOG_LENGTH, &logLength)); + if (logLength > 1) + { + char *infoLog = new char[logLength]; + ASSERT(infoLog != NULL); + + GLsizei infoLogLength = 0; + GL_CALL(glGetShaderInfoLog(m_fragmentShaderId, logLength, &infoLogLength, infoLog)); + LOG_ERROR(LOGCAT_OPENGL, "Error compiling fragment shader:\n%s\n", infoLog); + + SAFE_DELETE(infoLog); + } + } + + // only return success if both compiled successfully + if (m_fragmentShaderCompileStatus && m_vertexShaderCompileStatus) + return TRUE; + else + return FALSE; +} + +BOOL Shader::Link() +{ + STACK_TRACE; + ASSERT(m_vertexShaderId != 0); + ASSERT(m_fragmentShaderId != 0); + ASSERT(m_programId == 0); + + GL_CALL(m_programId = glCreateProgram()); + ASSERT(m_programId != 0); + + GL_CALL(glAttachShader(m_programId, m_vertexShaderId)); + GL_CALL(glAttachShader(m_programId, m_fragmentShaderId)); + + GL_CALL(glLinkProgram(m_programId)); + GL_CALL(glGetProgramiv(m_programId, GL_LINK_STATUS, &m_linkStatus)); + + // log linker errors + if (!m_linkStatus) + { + GLint logLength = 0; + GL_CALL(glGetProgramiv(m_programId, GL_INFO_LOG_LENGTH, &logLength)); + if (logLength > 1) + { + char *infoLog = new char[logLength]; + ASSERT(infoLog != NULL); + + GL_CALL(glGetProgramInfoLog(m_programId, logLength, NULL, infoLog)); + LOG_ERROR(LOGCAT_OPENGL, "Error linking program:\n%s\n", infoLog); + + SAFE_DELETE(infoLog); + } + } + + return m_linkStatus; +} + +void Shader::LoadUniformInfo() +{ + STACK_TRACE; + ASSERT(m_programId != 0); + + m_uniforms.clear(); + + GLint numUniforms = 0; + GL_CALL(glGetProgramiv(m_programId, GL_ACTIVE_UNIFORMS, &numUniforms)); + + // don't need to proceed if there are no uniforms + if (numUniforms == 0) + return; + + // get the maximum uniform name length for a temporary buffer to hold them + GLint maxUniformNameLength = 0; + GL_CALL(glGetProgramiv(m_programId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformNameLength)); + ASSERT(maxUniformNameLength > 0); + char *uniformName = new char[maxUniformNameLength]; + + // get info about each uniform + for (int32_t i = 0; i < numUniforms; ++i) + { + GLint size; + GLenum type; + GLint location; + + GL_CALL(glGetActiveUniform(m_programId, i, maxUniformNameLength, NULL, &size, &type, uniformName)); + GL_CALL(location = glGetUniformLocation(m_programId, uniformName)); + ASSERT(location != -1); // means the uniform is not active... this assert shouldn't ever fail really... + + // store the uniform info + ShaderUniform uniform; + uniform.location = (uint32_t)location; + uniform.type = (uint32_t)type; + uniform.size = (uint32_t)size; + stl::string name = uniformName; + + // it seems Windows/Mac (possibly Linux too) have differing opinions on + // including "[0]" in the uniform name for uniforms that are arrays + // we'll just chop any "[0]" off if found in the uniform name before we + // add it to our list + size_t arraySubscriptPos = name.find("[0]"); + if (arraySubscriptPos != stl::string::npos) + name = name.substr(0, arraySubscriptPos); + + m_uniforms[name] = uniform; + } + + SAFE_DELETE_ARRAY(uniformName); +} + +void Shader::LoadAttributeInfo() +{ + STACK_TRACE; + ASSERT(m_programId != 0); + + m_attributes.clear(); + + GLint numAttributes = 0; + GL_CALL(glGetProgramiv(m_programId, GL_ACTIVE_ATTRIBUTES, &numAttributes)); + + // sanity checking, which only matters for shader reloading (e.g. when a context is lost) + if (m_attributeMapping != NULL) + { + ASSERT((uint32_t)numAttributes == m_numAttributes); + } + + m_numAttributes = numAttributes; + + // don't need to proceed if there are no attributes + if (numAttributes == 0) + return; + + // leave existing attribute type mappings (they will already be there e.g. when a context is lost) + if (m_attributeMapping == NULL) + { + // just allocate this for now, will be bound later on + m_attributeMapping = new ShaderAttributeMapInfo[m_numAttributes]; + memset(m_attributeMapping, 0, sizeof(ShaderAttributeMapInfo) * m_numAttributes); + } + + // get the maximum attribute name length for a temporary buffer to hold them + GLint maxAttributeNameLength = 0; + GL_CALL(glGetProgramiv(m_programId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxAttributeNameLength)); + ASSERT(maxAttributeNameLength > 0); + char *attributeName = new char[maxAttributeNameLength]; + + // get info about each attribute + for (int32_t i = 0; i < numAttributes; ++i) + { + GLint size; + GLenum type; + GLint location; + + GL_CALL(glGetActiveAttrib(m_programId, i, maxAttributeNameLength, NULL, &size, &type, attributeName)); + GL_CALL(location = glGetAttribLocation(m_programId, attributeName)); + ASSERT(location != -1); // means the attribute is not active... this assert shouldn't ever fail really... + + // store the attribute info + ShaderAttribute attribute; + attribute.location = (uint32_t)location; + attribute.type = (uint32_t)type; + attribute.size = (uint32_t)size; + attribute.isTypeBound = FALSE; + stl::string name = attributeName; + + m_attributes[name] = attribute; + } + + SAFE_DELETE_ARRAY(attributeName); +} + +BOOL Shader::HasUniform(const stl::string &name) const +{ + STACK_TRACE; + ShaderUniformMap::const_iterator i = m_uniforms.find(name); + if (i == m_uniforms.end()) + return FALSE; + else + return TRUE; +} + +const ShaderUniform* Shader::GetUniform(const stl::string &name) const +{ + STACK_TRACE; + ShaderUniformMap::const_iterator i = m_uniforms.find(name); + if (i == m_uniforms.end()) + return NULL; + else + return &i->second; +} + +ShaderUniform* Shader::GetUniform(const stl::string &name) +{ + STACK_TRACE; + ShaderUniformMap::iterator i = m_uniforms.find(name); + if (i == m_uniforms.end()) + return NULL; + else + return &i->second; +} + +BOOL Shader::HasAttribute(const stl::string &name) const +{ + STACK_TRACE; + ShaderAttributeMap::const_iterator i = m_attributes.find(name); + if (i == m_attributes.end()) + return FALSE; + else + return TRUE; +} + +const ShaderAttribute* Shader::GetAttribute(const stl::string &name) const +{ + STACK_TRACE; + ShaderAttributeMap::const_iterator i = m_attributes.find(name); + if (i == m_attributes.end()) + return NULL; + else + return &i->second; +} + +ShaderAttribute* Shader::GetAttribute(const stl::string &name) +{ + STACK_TRACE; + ShaderAttributeMap::iterator i = m_attributes.find(name); + if (i == m_attributes.end()) + return NULL; + else + return &i->second; +} + +void Shader::CacheUniform(const stl::string &name, CachedShaderUniform uniform) +{ + STACK_TRACE; + m_cachedUniforms[name] = uniform; +} + +CachedShaderUniform* Shader::GetCachedUniform(const stl::string &name) +{ + STACK_TRACE; + CachedShaderUniformMap::iterator i = m_cachedUniforms.find(name); + if (i == m_cachedUniforms.end()) + { + m_cachedUniforms[name] = CachedShaderUniform(); + i = m_cachedUniforms.find(name); + } + + return &i->second; +} + +void Shader::FlushCachedUniforms() +{ + STACK_TRACE; + ASSERT(m_isBound == TRUE); + if (m_cachedUniforms.empty()) + return; + + for (CachedShaderUniformMap::iterator i = m_cachedUniforms.begin(); i != m_cachedUniforms.end(); ++i) + { + const stl::string &name = i->first; + CachedShaderUniform &uniform = i->second; + + switch (uniform.type) + { + case CACHED_UNIFORM_1F: SetUniform(name, uniform.f1.x); break; + case CACHED_UNIFORM_1I: SetUniform(name, uniform.i1.x); break; + case CACHED_UNIFORM_2F: SetUniform(name, uniform.f2.x, uniform.f2.y); break; + case CACHED_UNIFORM_2I: SetUniform(name, uniform.i2.x, uniform.i2.y); break; + case CACHED_UNIFORM_3F: SetUniform(name, uniform.f3.x, uniform.f3.y, uniform.f3.z); break; + case CACHED_UNIFORM_3I: SetUniform(name, uniform.i3.x, uniform.i3.y, uniform.i3.z); break; + case CACHED_UNIFORM_4F: SetUniform(name, uniform.f4.x, uniform.f4.y, uniform.f4.z, uniform.f4.w); break; + case CACHED_UNIFORM_4I: SetUniform(name, uniform.i4.x, uniform.i4.y, uniform.i4.z, uniform.i4.w); break; + case CACHED_UNIFORM_9F: + SetUniform(name, Matrix3x3(uniform.f9.m)); + break; + case CACHED_UNIFORM_16F: + SetUniform(name, Matrix4x4(uniform.f16.m)); + break; + } + } + + m_cachedUniforms.clear(); +} + +void Shader::SetUniform(const stl::string &name, float x) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform1f(uniform->location, x)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_1F; + uniform.f1.x = x; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, int32_t x) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform1i(uniform->location, x)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_1I; + uniform.i1.x = x; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, float x, float y) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform2f(uniform->location, x, y)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_2F; + uniform.f2.x = x; + uniform.f2.y = y; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector2 &v) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform2f(uniform->location, v.x, v.y)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_2F; + uniform.f2.x = v.x; + uniform.f2.y = v.y; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, int32_t x, int32_t y) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform2i(uniform->location, x, y)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_2I; + uniform.i2.x = x; + uniform.i2.y = y; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Point2 &p) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform2i(uniform->location, p.x, p.y)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_2I; + uniform.i2.x = p.x; + uniform.i2.y = p.y; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, float x, float y, float z) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform3f(uniform->location, x, y, z)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_3F; + uniform.f3.x = x; + uniform.f3.y = y; + uniform.f3.z = z; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector3 &v) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform3f(uniform->location, v.x, v.y, v.z)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_3F; + uniform.f3.x = v.x; + uniform.f3.y = v.y; + uniform.f3.z = v.z; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, int32_t x, int32_t y, int32_t z) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform3i(uniform->location, x, y, z)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_3I; + uniform.i3.x = x; + uniform.i3.y = y; + uniform.i3.z = z; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Point3 &p) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform3i(uniform->location, p.x, p.y, p.z)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_3I; + uniform.i3.x = p.x; + uniform.i3.y = p.y; + uniform.i3.z = p.z; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, float x, float y, float z, float w) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform4f(uniform->location, x, y, z, w)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_4F; + uniform.f4.x = x; + uniform.f4.y = y; + uniform.f4.z = z; + uniform.f4.w = w; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector4 &v) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform4f(uniform->location, v.x, v.y, v.z, v.w)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_4F; + uniform.f4.x = v.x; + uniform.f4.y = v.y; + uniform.f4.z = v.z; + uniform.f4.w = v.w; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Quaternion &q) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform4f(uniform->location, q.x, q.y, q.z, q.w)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_4F; + uniform.f4.x = q.x; + uniform.f4.y = q.y; + uniform.f4.z = q.z; + uniform.f4.w = q.w; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Color &c) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform4f(uniform->location, c.r, c.g, c.b, c.a)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_4F; + uniform.f4.x = c.r; + uniform.f4.y = c.g; + uniform.f4.z = c.b; + uniform.f4.w = c.a; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, int32_t x, int32_t y, int32_t z, int32_t w) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniform4i(uniform->location, x, y, z, w)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_4I; + uniform.i4.x = x; + uniform.i4.y = y; + uniform.i4.z = z; + uniform.i4.w = w; + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Matrix3x3 &m) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniformMatrix3fv(uniform->location, 1, FALSE, m.m)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_9F; + memcpy(uniform.f9.m, m.m, sizeof(float) * 9); + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const Matrix4x4 &m) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size == 1); + GL_CALL(glUniformMatrix4fv(uniform->location, 1, FALSE, m.m)); + } + else + { + CachedShaderUniform uniform; + uniform.type = CACHED_UNIFORM_16F; + memcpy(uniform.f16.m, m.m, sizeof(float) * 16); + CacheUniform(name, uniform); + } +} + +void Shader::SetUniform(const stl::string &name, const float *x, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + GL_CALL(glUniform1fv(uniform->location, count, x)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector2 *v, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)v; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + GL_CALL(glUniform2fv(uniform->location, count, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector3 *v, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)v; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + GL_CALL(glUniform3fv(uniform->location, count, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Vector4 *v, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)v; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + GL_CALL(glUniform4fv(uniform->location, count, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Quaternion *q, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)q; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + + GL_CALL(glUniform4fv(uniform->location, count, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Color *c, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)c; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + + GL_CALL(glUniform4fv(uniform->location, count, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Matrix3x3 *m, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)m; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + + GL_CALL(glUniformMatrix3fv(uniform->location, count, FALSE, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::SetUniform(const stl::string &name, const Matrix4x4 *m, uint32_t count) +{ + STACK_TRACE; + if (m_isBound) + { + // TODO: erm... this _seems_ unnecessarily ugly... even for me + const float *values = (const float*)m; + + const ShaderUniform *uniform = GetUniform(name); + ASSERT(uniform != NULL); + ASSERT(uniform->size >= count); + + GL_CALL(glUniformMatrix4fv(uniform->location, count, FALSE, values)); + } + else + { + ASSERT(!"Unimplemented"); + } +} + +void Shader::MapAttributeToVboAttribIndex(const stl::string &name, uint32_t vboAttribIndex) +{ + STACK_TRACE; + ShaderAttribute *attribute = GetAttribute(name); + ASSERT(attribute != NULL); + ASSERT(attribute->location < m_numAttributes); + + ShaderAttributeMapInfo *mappingInfo = &m_attributeMapping[attribute->location]; + mappingInfo->usesStandardType = FALSE; + mappingInfo->attribIndex = vboAttribIndex; + + attribute->isTypeBound = TRUE; +} + +void Shader::MapAttributeToStandardAttribType(const stl::string &name, VERTEX_ATTRIBS standardAttribType) +{ + STACK_TRACE; + ShaderAttribute *attribute = GetAttribute(name); + ASSERT(attribute != NULL); + ASSERT(attribute->location < m_numAttributes); + + ShaderAttributeMapInfo *mappingInfo = &m_attributeMapping[attribute->location]; + mappingInfo->usesStandardType = TRUE; + mappingInfo->standardType = standardAttribType; + + attribute->isTypeBound = TRUE; +} + +void Shader::OnNewContext() +{ + STACK_TRACE; + ReloadCompileAndLink(NULL, NULL); +} + +void Shader::OnLostContext() +{ + STACK_TRACE; +} + +void Shader::OnBind() +{ + STACK_TRACE; + ASSERT(m_isBound == FALSE); + m_isBound = TRUE; + FlushCachedUniforms(); +} + +void Shader::OnUnbind() +{ + STACK_TRACE; + ASSERT(m_isBound == TRUE); + m_isBound = FALSE; + m_cachedUniforms.clear(); +} diff --git a/src/framework/graphics/shader.h b/src/framework/graphics/shader.h new file mode 100644 index 0000000..4ebae91 --- /dev/null +++ b/src/framework/graphics/shader.h @@ -0,0 +1,396 @@ +#ifndef __FRAMEWORK_GRAPHICS_SHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SHADER_H_INCLUDED__ + +#include "../common.h" +#include "graphicscontextresource.h" +#include "shaderstructs.h" +#include "vertexattribs.h" + +class Text; +struct Color; +struct Point2; +struct Point3; +struct Vector2; +struct Vector3; +struct Vector4; +struct Matrix3x3; +struct Matrix4x4; +struct Quaternion; + +/** + * Represents a GLSL vertex and fragment shader compiled into a program that + * can be used for rendering. + */ +class Shader : public GraphicsContextResource +{ + friend class GraphicsDevice; + +public: + /** + * Creates a new shader object using the given vertex and fragment shader + * sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + Shader(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Creates a new shader object using the given vertex and fragment shader + * sources. + * @param vertexShaderSource GLSL source for a vertex shader + * @param fragmentShaderSource GLSL source for a vertex shader + */ + Shader(const Text *vertexShaderSource, const Text *fragmentShaderSource); + + virtual ~Shader(); + + /** + * @return TRUE if this shader has been compiled and linked into a program + * that can be bound and rendered with + */ + BOOL IsReadyForUse() const; + + /** + * @return TRUE if this shader is currently bound to the graphics device + */ + BOOL IsBound() const { return m_isBound; } + + /** + * @return TRUE if the vertex shader was compiled without errors + */ + BOOL GetVertexShaderCompileStatus() const { return m_vertexShaderCompileStatus; } + + /** + * @return TRUE if the fragment shader was compiled without errors + */ + BOOL GetFragmentShaderCompileStatus() const { return m_fragmentShaderCompileStatus; } + + /** + * @return TRUE if the compiled vertex and fragment shaders were linked + * without errors + */ + BOOL GetLinkStatus() const { return m_linkStatus; } + + /** + * @return the OpenGL program ID that can be bound + */ + uint32_t GetProgramId() const { return m_programId; } + + /** + * Checks if this shader contains a uniform. Note that the GLSL compiler + * could optimize out uniforms if they aren't used in the GLSL code. + * @param name the name of the uniform to check for + * @return TRUE if the uniform is present + */ + BOOL HasUniform(const stl::string &name) const; + + /** + * Checks if this shader contains an attribute. Note that the GLSL + * compiler could optimize out attributes if they aren't used in the + * GLSL code. + * @param name the name of the attribute to check for + * @return TRUE if the attribute is present + */ + BOOL HasAttribute(const stl::string &name) const; + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, float x); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, int32_t x); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, float x, float y); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Vector2 &v); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, int32_t x, int32_t y); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Point2 &p); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, float x, float y, float z); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Vector3 &v); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, int32_t x, int32_t y, int32_t z); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Point3 &p); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, float x, float y, float z, float w); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Vector4 &v); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Quaternion &q); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Color &c); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, int32_t x, int32_t y, int32_t z, int32_t w); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Matrix3x3 &m); + + /** + * Sets the value of a uniform. + * @param name the name of the uniform to set + */ + void SetUniform(const stl::string &name, const Matrix4x4 &m); + + void SetUniform(const stl::string &name, const float *x, uint32_t count); + void SetUniform(const stl::string &name, const Vector2 *v, uint32_t count); + void SetUniform(const stl::string &name, const Vector3 *v, uint32_t count); + void SetUniform(const stl::string &name, const Vector4 *v, uint32_t count); + void SetUniform(const stl::string &name, const Quaternion *q, uint32_t count); + void SetUniform(const stl::string &name, const Color *c, uint32_t count); + void SetUniform(const stl::string &name, const Matrix3x3 *m, uint32_t count); + void SetUniform(const stl::string &name, const Matrix4x4 *m, uint32_t count); + + /** + * @return the number of attributes used in this shader + */ + uint32_t GetNumAttributes() const { return m_numAttributes; } + + /** + * Returns whether the given shader attribute has been mapped to a standard + * attribute type or not. + * @param attribIndex the index of the shader attribute to check the + * mapping of + * @return TRUE if this shader attribute was mapped to a standard attribute + * type or FALSE if it wasn't + */ + BOOL IsAttributeMappedToStandardType(uint32_t attribIndex) const; + + /** + * Gets a vertex buffer object attribute index that corresponds to the + * specified shader attribute. + * @param attribIndex the index of the shader attribute to get the mapping + * for + * @return an index for a vertex buffer object's attributes that + * corresponds to the specified shader attribute + */ + uint32_t GetAttributeMappedBufferIndex(uint32_t attribIndex) const; + + /** + * Gets the standard attribute type mapping corresponding to the given + * shader attribute. + * @param attribIndex the index of the shader attribute to get the mapping + * for + * @return the standard attribute type mapping associated with this + * shader attribute + */ + VERTEX_ATTRIBS GetAttributeMappedStandardType(uint32_t attribIndex) const; + + /** + * Maps the given shader attribute to an index that will be used to refer + * to an attribute in bound vertex buffer objects. This will be used by + * GraphicsDevice when the shader is bound to automatically set up the + * OpenGL vertex attribute mappings. + * @param name the name of the attribute to map + * @param vboAttribIndex the index value to map that will be used to refer + * to an attribute in bound vertex buffer objects + */ + void MapAttributeToVboAttribIndex(const stl::string &name, uint32_t vboAttribIndex); + + /** + * Maps the given shader attribute so that it will correspond to an + * attribute matching the provided standard type in bound vertex buffer + * objects, regardless of what attribute index it is located at. This will + * be used by GraphicsDevice when the shader is bound to automatically set + * up the OpenGL vertex attribute mappings. + * @param name the name of the attribute to map + * @param standardAttribType the standard type to map this shader attribute + * to in bound vertex buffer objects + */ + void MapAttributeToStandardAttribType(const stl::string &name, VERTEX_ATTRIBS standardAttribType); + + /** + * New OpenGL graphics context creation callback. + */ + virtual void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + virtual void OnLostContext(); + +protected: + /** + * Initializes internal shader state in preparation for vertex and + * fragment sources to be provided. + */ + Shader(); + + /** + * Loads the provided shader sources, compiles and links them and + * caches information about attributes and uniforms. + * @param vertexShaderSource vertex shader source + * @param fragmentShaderSource fragment shader source + * @return TRUE if compilation and linking succeeded and the shader + * is now ready for use + */ + BOOL LoadCompileAndLink(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Reloads shader sources either from those provided or from the + * internal cache. This should be used when the OpenGL context + * was lost and recreated. + * @param vertexShaderSource vertex shader source, or NULL to load + * the source from the cache + * @param fragmentShaderSource fragment shader source, or NULL to load + * the source from the cache + * @return TRUE if compilation and linking succeeded and the shader + * is now ready for use + */ + BOOL ReloadCompileAndLink(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Caches the provided shader sources. ReloadCompileAndLink() can + * be called with NULL arguments to reload from this cache later. + * @param vertexShaderSource vertex shader source to cache + * @param fragmentShaderSource fragment shader source to cache + */ + void CacheShaderSources(const char *vertexShaderSource, const char *fragmentShaderSource); + + /** + * Gets information about the specified uniform. + * @param name the name of the uniform to get info about + * @return information about the specified uniform or NULL if not found + */ + const ShaderUniform* GetUniform(const stl::string &name) const; + + /** + * Gets information about the specified uniform. + * @param name the name of the uniform to get info about + * @return information about the specified uniform or NULL if not found + */ + ShaderUniform* GetUniform(const stl::string &name); + + /** + * Gets information about the specified attribute. + * @param name the name of the attribute to get info about + * @return information about the specified attribute or NULL if not found + */ + const ShaderAttribute* GetAttribute(const stl::string &name) const; + + /** + * Gets information about the specified attribute. + * @param name the name of the attribute to get info about + * @return information about the specified attribute or NULL if not found + */ + ShaderAttribute* GetAttribute(const stl::string &name); + +private: + void Initialize(); + BOOL Compile(const char *vertexShaderSource, const char *fragmentShaderSource); + BOOL Link(); + void LoadUniformInfo(); + void LoadAttributeInfo(); + + void CacheUniform(const stl::string &name, CachedShaderUniform uniform); + CachedShaderUniform* GetCachedUniform(const stl::string &name); + void FlushCachedUniforms(); + + void OnBind(); + void OnUnbind(); + + char *m_cachedVertexShaderSource; + char *m_cachedFragmentShaderSource; + BOOL m_vertexShaderCompileStatus; + BOOL m_fragmentShaderCompileStatus; + BOOL m_linkStatus; + uint32_t m_vertexShaderId; + uint32_t m_fragmentShaderId; + uint32_t m_programId; + BOOL m_isBound; + + ShaderUniformMap m_uniforms; + ShaderAttributeMap m_attributes; + ShaderAttributeMapInfo *m_attributeMapping; + uint32_t m_numAttributes; + + CachedShaderUniformMap m_cachedUniforms; +}; + +inline BOOL Shader::IsReadyForUse() const +{ + if (GetVertexShaderCompileStatus() && GetFragmentShaderCompileStatus() && GetLinkStatus()) + return TRUE; + else + return FALSE; +} + +inline BOOL Shader::IsAttributeMappedToStandardType(uint32_t attribIndex) const +{ + return m_attributeMapping[attribIndex].usesStandardType; +} + +inline uint32_t Shader::GetAttributeMappedBufferIndex(uint32_t attribIndex) const +{ + return m_attributeMapping[attribIndex].attribIndex; +} + +inline VERTEX_ATTRIBS Shader::GetAttributeMappedStandardType(uint32_t attribIndex) const +{ + return m_attributeMapping[attribIndex].standardType; +} + +#endif diff --git a/src/framework/graphics/shaderstructs.h b/src/framework/graphics/shaderstructs.h new file mode 100644 index 0000000..2c3cfb3 --- /dev/null +++ b/src/framework/graphics/shaderstructs.h @@ -0,0 +1,142 @@ +#ifndef __FRAMEWORK_GRAPHICS_SHADERSTRUCTS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SHADERSTRUCTS_H_INCLUDED__ + +#include "../common.h" +#include "vertexattribs.h" + +#include +#include + +/** + * Metadata about a shader uniform. + */ +struct ShaderUniform +{ + uint32_t location; + uint32_t type; + uint32_t size; +}; + +/** + * Metadata about a shader attribute. + */ +struct ShaderAttribute +{ + uint32_t location; + uint32_t type; + uint32_t size; + BOOL isTypeBound; +}; + +/** + * Shader attribute to vertex buffer attribute mapping information. + */ +struct ShaderAttributeMapInfo +{ + BOOL usesStandardType; + VERTEX_ATTRIBS standardType; + uint32_t attribIndex; +}; + +/** + * Type enum for temporarily cached shader uniform values. + */ +enum CACHED_SHADER_UNIFORM_TYPE +{ + CACHED_UNIFORM_1F, + CACHED_UNIFORM_1I, + CACHED_UNIFORM_2F, + CACHED_UNIFORM_2I, + CACHED_UNIFORM_3F, + CACHED_UNIFORM_3I, + CACHED_UNIFORM_4F, + CACHED_UNIFORM_4I, + CACHED_UNIFORM_9F, + CACHED_UNIFORM_16F +}; + +/** + * Holds type and value for temporarily cached shader uniform values. + */ +struct CachedShaderUniform +{ + CACHED_SHADER_UNIFORM_TYPE type; + union + { + struct + { + float x; + } f1; + struct + { + int32_t x; + } i1; + struct + { + float x; + float y; + } f2; + struct + { + int32_t x; + int32_t y; + } i2; + struct + { + float x; + float y; + float z; + } f3; + struct + { + int32_t x; + int32_t y; + int32_t z; + } i3; + struct + { + float x; + float y; + float z; + float w; + } f4; + struct + { + int32_t x; + int32_t y; + int32_t z; + int32_t w; + } i4; + struct + { + float m[9]; + } f9; + struct + { + float m[16]; + } f16; + }; +}; + +struct CachedShaderArrayUniform +{ + CACHED_SHADER_UNIFORM_TYPE type; + uint32_t count; + float *values; + + CachedShaderArrayUniform() + { + values = NULL; + } + + ~CachedShaderArrayUniform() + { + SAFE_DELETE_ARRAY(values); + } +}; + +typedef stl::map ShaderUniformMap; +typedef stl::map ShaderAttributeMap; +typedef stl::map CachedShaderUniformMap; + +#endif diff --git a/src/framework/graphics/simplecolorshader.cpp b/src/framework/graphics/simplecolorshader.cpp new file mode 100644 index 0000000..d37cb18 --- /dev/null +++ b/src/framework/graphics/simplecolorshader.cpp @@ -0,0 +1,46 @@ +#include "../debug.h" + +#include "simplecolorshader.h" + +const char* SimpleColorShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec4 a_color;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "\n" + "void main()\n" + "{\n" + " v_color = a_color;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* SimpleColorShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " #define LOWP lowp\n" + " precision mediump float;\n" + "#else\n" + " #define LOWP\n" + "#endif\n" + "varying LOWP vec4 v_color;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = v_color;\n" + "}\n"; + +SimpleColorShader::SimpleColorShader() + : StandardShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_color", VERTEX_COLOR); +} + +SimpleColorShader::~SimpleColorShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/simplecolorshader.h b/src/framework/graphics/simplecolorshader.h new file mode 100644 index 0000000..382d75f --- /dev/null +++ b/src/framework/graphics/simplecolorshader.h @@ -0,0 +1,20 @@ +#ifndef __FRAMEWORK_GRAPHICS_SIMPLECOLORSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SIMPLECOLORSHADER_H_INCLUDED__ + +#include "standardshader.h" + +/** + * Shader which renders geometry with vertex colors but no textures. + */ +class SimpleColorShader : public StandardShader +{ +public: + SimpleColorShader(); + virtual ~SimpleColorShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/simplecolortextureshader.cpp b/src/framework/graphics/simplecolortextureshader.cpp new file mode 100644 index 0000000..512ef38 --- /dev/null +++ b/src/framework/graphics/simplecolortextureshader.cpp @@ -0,0 +1,52 @@ +#include "../debug.h" + +#include "simplecolortextureshader.h" + +const char* SimpleColorTextureShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec4 a_color;\n" + "attribute vec2 a_texcoord0;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "\n" + "void main()\n" + "{\n" + " v_color = a_color;\n" + " v_texCoords = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* SimpleColorTextureShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " #define LOWP lowp\n" + " precision mediump float;\n" + "#else\n" + " #define LOWP\n" + "#endif\n" + "varying LOWP vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = v_color * texture2D(u_texture, v_texCoords);\n" + "}\n"; + +SimpleColorTextureShader::SimpleColorTextureShader() + : StandardShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_color", VERTEX_COLOR); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +SimpleColorTextureShader::~SimpleColorTextureShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/simplecolortextureshader.h b/src/framework/graphics/simplecolortextureshader.h new file mode 100644 index 0000000..6bf7695 --- /dev/null +++ b/src/framework/graphics/simplecolortextureshader.h @@ -0,0 +1,20 @@ +#ifndef __FRAMEWORK_GRAPHICS_SIMPLECOLORTEXTURESHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SIMPLECOLORTEXTURESHADER_H_INCLUDED__ + +#include "standardshader.h" + +/** + * Shader which renders geometry using vertex colors modulated with a texture. + */ +class SimpleColorTextureShader : public StandardShader +{ +public: + SimpleColorTextureShader(); + virtual ~SimpleColorTextureShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/simpletextureshader.cpp b/src/framework/graphics/simpletextureshader.cpp new file mode 100644 index 0000000..c85bfe4 --- /dev/null +++ b/src/framework/graphics/simpletextureshader.cpp @@ -0,0 +1,45 @@ +#include "../debug.h" + +#include "simpletextureshader.h" + +const char* SimpleTextureShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec2 a_texcoord0;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "\n" + "void main()\n" + "{\n" + " v_texCoords = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* SimpleTextureShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " precision mediump float;\n" + "#endif\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = texture2D(u_texture, v_texCoords);\n" + "}\n"; + +SimpleTextureShader::SimpleTextureShader() + : StandardShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +SimpleTextureShader::~SimpleTextureShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/simpletextureshader.h b/src/framework/graphics/simpletextureshader.h new file mode 100644 index 0000000..62983b9 --- /dev/null +++ b/src/framework/graphics/simpletextureshader.h @@ -0,0 +1,20 @@ +#ifndef __FRAMEWORK_GRAPHICS_SIMPLETEXTURESHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SIMPLETEXTURESHADER_H_INCLUDED__ + +#include "standardshader.h" + +/** + * Shader which renders geometry with texturing but no vertex colors. + */ +class SimpleTextureShader : public StandardShader +{ +public: + SimpleTextureShader(); + virtual ~SimpleTextureShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/simpletexturevertexlerpshader.cpp b/src/framework/graphics/simpletexturevertexlerpshader.cpp new file mode 100644 index 0000000..a64ebcf --- /dev/null +++ b/src/framework/graphics/simpletexturevertexlerpshader.cpp @@ -0,0 +1,48 @@ +#include "../debug.h" + +#include "simpletexturevertexlerpshader.h" + +const char* SimpleTextureVertexLerpShader::m_vertexShaderSource = + "attribute vec4 a_position1;\n" + "attribute vec4 a_position2;\n" + "attribute vec2 a_texcoord0;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "uniform float u_lerp;\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "\n" + "void main()\n" + "{\n" + " v_texCoords = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * mix(a_position1, a_position2, u_lerp);\n" + "}\n"; + +const char* SimpleTextureVertexLerpShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " precision mediump float;\n" + "#endif\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = texture2D(u_texture, v_texCoords);\n" + "}\n"; + +SimpleTextureVertexLerpShader::SimpleTextureVertexLerpShader() + : VertexLerpShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToVboAttribIndex("a_position1", 0); + MapAttributeToVboAttribIndex("a_position2", 1); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +SimpleTextureVertexLerpShader::~SimpleTextureVertexLerpShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/simpletexturevertexlerpshader.h b/src/framework/graphics/simpletexturevertexlerpshader.h new file mode 100644 index 0000000..7d7f5bd --- /dev/null +++ b/src/framework/graphics/simpletexturevertexlerpshader.h @@ -0,0 +1,17 @@ +#ifndef __FRAMEWORK_GRAPHICS_SIMPLETEXTUREVERTEXLERPSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SIMPLETEXTUREVERTEXLERPSHADER_H_INCLUDED__ + +#include "vertexlerpshader.h" + +class SimpleTextureVertexLerpShader : public VertexLerpShader +{ +public: + SimpleTextureVertexLerpShader(); + virtual ~SimpleTextureVertexLerpShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/simpletexturevertexskinningshader.cpp b/src/framework/graphics/simpletexturevertexskinningshader.cpp new file mode 100644 index 0000000..20a07fc --- /dev/null +++ b/src/framework/graphics/simpletexturevertexskinningshader.cpp @@ -0,0 +1,66 @@ +#include "../debug.h" + +#include "simpletexturevertexskinningshader.h" + +const char* SimpleTextureVertexSkinningShader::m_vertexShaderSource = + "#ifdef GL_ES\n" + " precision mediump float;\n" + "#endif\n" + "\n" + "const int MAX_BONES = 50;\n" + "\n" + "attribute vec4 a_position;\n" + "attribute vec2 a_texcoord0;\n" + "attribute float a_jointIndex;\n" + "\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "uniform vec3 u_jointPositions[MAX_BONES];\n" + "uniform vec4 u_jointRotations[MAX_BONES];\n" + "\n" + "varying vec2 v_texCoord;\n" + "\n" + "vec3 qtransform(vec4 q, vec3 v)\n" + "{ \n" + " vec3 temp = cross(q.xyz, v) + q.w * v;\n" + " return cross(temp, -q.xyz) + dot(q.xyz,v) * q.xyz + q.w * temp;\n" + "}\n" + "\n" + "void main()\n" + "{\n" + " int j = int(a_jointIndex);\n" + "\n" + " vec4 skinnedPosition = vec4(qtransform(u_jointRotations[j], a_position.xyz) + u_jointPositions[j], 1.0);\n" + "\n" + " v_texCoord = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * skinnedPosition;\n" + "}\n"; + +const char* SimpleTextureVertexSkinningShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " precision mediump float;\n" + "#endif\n" + "varying vec2 v_texCoord;\n" + "uniform sampler2D u_texture;\n" + "\n" + "void main()\n" + "{\n" + " gl_FragColor = texture2D(u_texture, v_texCoord);\n" + "}\n"; + +SimpleTextureVertexSkinningShader::SimpleTextureVertexSkinningShader() + : VertexSkinningShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToVboAttribIndex("a_jointIndex", 0); + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +SimpleTextureVertexSkinningShader::~SimpleTextureVertexSkinningShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/simpletexturevertexskinningshader.h b/src/framework/graphics/simpletexturevertexskinningshader.h new file mode 100644 index 0000000..036380f --- /dev/null +++ b/src/framework/graphics/simpletexturevertexskinningshader.h @@ -0,0 +1,17 @@ +#ifndef __FRAMEWORK_GRAPHICS_SIMPLETEXTUREVERTEXSKINNINGSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SIMPLETEXTUREVERTEXSKINNINGSHADER_H_INCLUDED__ + +#include "vertexskinningshader.h" + +class SimpleTextureVertexSkinningShader : public VertexSkinningShader +{ +public: + SimpleTextureVertexSkinningShader(); + virtual ~SimpleTextureVertexSkinningShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/solidcolortexturecache.cpp b/src/framework/graphics/solidcolortexturecache.cpp new file mode 100644 index 0000000..ba550b4 --- /dev/null +++ b/src/framework/graphics/solidcolortexturecache.cpp @@ -0,0 +1,111 @@ +#include "../debug.h" +#include "../log.h" +#include "../common.h" + +#include "solidcolortexturecache.h" +#include "color.h" +#include "graphicsdevice.h" +#include "image.h" +#include "texture.h" +#include + +SolidColorTextureCache::SolidColorTextureCache(GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + m_graphicsDevice = graphicsDevice; +} + +SolidColorTextureCache::~SolidColorTextureCache() +{ + STACK_TRACE; + FreeAll(); +} + +void SolidColorTextureCache::OnNewContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "SolidColorTextureCache: regenerating previous textures for new OpenGL context.\n"); + + for (ColorTextureMap::iterator itor = m_textures.begin(); itor != m_textures.end(); ++itor) + { + Color color = Color::FromInt(itor->first); + Texture *reloaded = CreateFor(color, itor->second); + if (reloaded == NULL) + LOG_WARN(LOGCAT_ASSETS, "SolidColorTextureCache: failed reloading texture for color 0x%8x.\n", color.ToInt()); + } +} + +void SolidColorTextureCache::OnLostContext() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "SolidColorTextureCache: resetting generated texture IDs due to lost OpenGL context.\n"); + + for (ColorTextureMap::iterator itor = m_textures.begin(); itor != m_textures.end(); ++itor) + itor->second->OnLostContext(); +} + +Texture* SolidColorTextureCache::Get(const Color &color) +{ + STACK_TRACE; + Texture *texture; + uint32_t colorInt = color.ToInt(); + + ColorTextureMap::iterator itor = m_textures.find(colorInt); + if (itor != m_textures.end()) + texture = itor->second; + else + { + texture = CreateFor(color); + if (texture != NULL) + m_textures[colorInt] = texture; + } + + return texture; +} + +Texture* SolidColorTextureCache::CreateFor(const Color &color, Texture *existing) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "SolidColorTextureCache: creating texture for color 0x%8x.\n", color.ToInt()); + + Image *img = new Image(); + BOOL imageCreateSuccess = img->Create(8, 8, IMAGE_FORMAT_RGBA); + ASSERT(imageCreateSuccess == TRUE); + + Texture *texture; + if (existing != NULL) + { + texture = existing; + texture->Release(); + } + else + texture = new Texture(); + + img->Clear(color); + BOOL success = texture->Create(m_graphicsDevice, img); + SAFE_DELETE(img); + + if (!success) + { + // if we allocated the texture ourselves, we should free it + if (existing != NULL) + { + SAFE_DELETE(texture); + } + } + + return texture; +} + +void SolidColorTextureCache::FreeAll() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_ASSETS, "SolidColorTextureCache: freeing all generated textures.\n"); + for (ColorTextureMap::iterator itor = m_textures.begin(); itor != m_textures.end(); ++itor) + { + SAFE_DELETE(itor->second); + } + + m_textures.clear(); +} + diff --git a/src/framework/graphics/solidcolortexturecache.h b/src/framework/graphics/solidcolortexturecache.h new file mode 100644 index 0000000..70c9e8d --- /dev/null +++ b/src/framework/graphics/solidcolortexturecache.h @@ -0,0 +1,54 @@ +#ifndef __FRAMEWORK_GRAPHICS_SOLIDCOLORTEXTURECACHE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SOLIDCOLORTEXTURECACHE_H_INCLUDED__ + +#include "../common.h" +#include + +class GraphicsDevice; +class Texture; +struct Color; + +typedef stl::map ColorTextureMap; + +/** + * Cache of textures that are filled with solid colors only. + */ +class SolidColorTextureCache +{ +public: + /** + * Creates a solid color texture cache. + * @param graphicsDevice the graphics device used to create textures with + */ + SolidColorTextureCache(GraphicsDevice *graphicsDevice); + + virtual ~SolidColorTextureCache(); + + /** + * New OpenGL graphics context creation callback. + */ + void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + void OnLostContext(); + + /** + * Gets a texture that is filled with a single solid color. If this texture + * has not been created yet it will be first, then returned. + * @param the color to get a texture for + * @return the texture or NULL on failure + */ + Texture* Get(const Color &color); + +private: + Texture* CreateFor(const Color &color, Texture *existing = NULL); + void FreeAll(); + + GraphicsDevice *m_graphicsDevice; + ColorTextureMap m_textures; +}; + +#endif + diff --git a/src/framework/graphics/sprite2dshader.cpp b/src/framework/graphics/sprite2dshader.cpp new file mode 100644 index 0000000..2794391 --- /dev/null +++ b/src/framework/graphics/sprite2dshader.cpp @@ -0,0 +1,58 @@ +#include "../debug.h" + +#include "sprite2dshader.h" + +const char* Sprite2DShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec4 a_color;\n" + "attribute vec2 a_texcoord0;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "\n" + "void main()\n" + "{\n" + " v_color = a_color;\n" + " v_texCoords = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* Sprite2DShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " #define LOWP lowp\n" + " precision mediump float;\n" + "#else\n" + " #define LOWP\n" + "#endif\n" + "varying LOWP vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "uniform bool u_textureHasAlphaOnly;\n" + "\n" + "void main()\n" + "{\n" + " vec4 finalColor;\n" + " if (u_textureHasAlphaOnly)\n" + " finalColor = vec4(v_color.xyz, (v_color.a * texture2D(u_texture, v_texCoords).a));\n" + " else\n" + " finalColor = v_color * texture2D(u_texture, v_texCoords);\n" + " gl_FragColor = finalColor;\n" + "}\n"; + +Sprite2DShader::Sprite2DShader() + : SpriteShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_2D); + MapAttributeToStandardAttribType("a_color", VERTEX_COLOR); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +Sprite2DShader::~Sprite2DShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/sprite2dshader.h b/src/framework/graphics/sprite2dshader.h new file mode 100644 index 0000000..a8649c2 --- /dev/null +++ b/src/framework/graphics/sprite2dshader.h @@ -0,0 +1,22 @@ +#ifndef __FRAMEWORK_GRAPHICS_SPRITE2DSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SPRITE2DSHADER_H_INCLUDED__ + +#include "spriteshader.h" + +/** + * Shader for rendering 2D sprites with vertex color modulation. Includes + * special support for color modulation using RGB, RGBA, and alpha-only + * texture formats. + */ +class Sprite2DShader : public SpriteShader +{ +public: + Sprite2DShader(); + virtual ~Sprite2DShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/sprite3dshader.cpp b/src/framework/graphics/sprite3dshader.cpp new file mode 100644 index 0000000..2daed25 --- /dev/null +++ b/src/framework/graphics/sprite3dshader.cpp @@ -0,0 +1,64 @@ +#include "../debug.h" + +#include "sprite3dshader.h" + +const char* Sprite3DShader::m_vertexShaderSource = + "attribute vec4 a_position;\n" + "attribute vec4 a_color;\n" + "attribute vec2 a_texcoord0;\n" + "uniform mat4 u_modelViewMatrix;\n" + "uniform mat4 u_projectionMatrix;\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "\n" + "void main()\n" + "{\n" + " v_color = a_color;\n" + " v_texCoords = a_texcoord0;\n" + " gl_Position = u_projectionMatrix * u_modelViewMatrix * a_position;\n" + "}\n"; + +const char* Sprite3DShader::m_fragmentShaderSource = + "#ifdef GL_ES\n" + " #define LOWP lowp\n" + " precision mediump float;\n" + "#else\n" + " #define LOWP\n" + "#endif\n" + "varying LOWP vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "uniform bool u_textureHasAlphaOnly;\n" + "\n" + "void main()\n" + "{\n" + " vec4 texColor = texture2D(u_texture, v_texCoords);\n" + " if (texColor.a > 0.0)\n" + " {\n" + " vec4 finalColor;\n" + " if (u_textureHasAlphaOnly)\n" + " finalColor = vec4(v_color.xyz, (v_color.a * texColor.a));\n" + " else\n" + " finalColor = v_color * texColor;\n" + " gl_FragColor = finalColor;\n" + " }\n" + " else\n" + " discard;\n" + "}\n"; + +Sprite3DShader::Sprite3DShader() + : SpriteShader() +{ + STACK_TRACE; + BOOL result = LoadCompileAndLinkInlineSources(m_vertexShaderSource, m_fragmentShaderSource); + ASSERT(result == TRUE); + + MapAttributeToStandardAttribType("a_position", VERTEX_POS_3D); + MapAttributeToStandardAttribType("a_color", VERTEX_COLOR); + MapAttributeToStandardAttribType("a_texcoord0", VERTEX_TEXCOORD); +} + +Sprite3DShader::~Sprite3DShader() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/sprite3dshader.h b/src/framework/graphics/sprite3dshader.h new file mode 100644 index 0000000..48bd82f --- /dev/null +++ b/src/framework/graphics/sprite3dshader.h @@ -0,0 +1,23 @@ +#ifndef __FRAMEWORK_GRAPHICS_SPRITE3DSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SPRITE3DSHADER_H_INCLUDED__ + +#include "spriteshader.h" + +/** + * Shader for rendering 3D billboard sprites with vertex color modulation. + * Includes special support for color modulation using RGB, RGBA, and + * alpha-only texture formats. Also performs alpha testing (fragments with + * alpha == 0.0f are discarded). + */ +class Sprite3DShader : public SpriteShader +{ +public: + Sprite3DShader(); + virtual ~Sprite3DShader(); + +private: + static const char *m_vertexShaderSource; + static const char *m_fragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/spritebatch.cpp b/src/framework/graphics/spritebatch.cpp new file mode 100644 index 0000000..0df5256 --- /dev/null +++ b/src/framework/graphics/spritebatch.cpp @@ -0,0 +1,955 @@ +#include "../debug.h" + +#include "spritebatch.h" + +#include +#include +#include + +#include "blendstate.h" +#include "graphicsdevice.h" +#include "renderstate.h" +#include "shader.h" +#include "spritefont.h" +#include "spriteshader.h" +#include "sprite2dshader.h" +#include "texture.h" +#include "textureatlas.h" +#include "vertexbuffer.h" +#include "viewcontext.h" +#include "../math/camera.h" +#include "../math/mathhelpers.h" +#include "../math/point2.h" +#include "../math/rect.h" +#include "../math/vector3.h" + +const size_t PRINTF_BUFFER_SIZE = 8096; +char __spriteBatch_printfBuffer[PRINTF_BUFFER_SIZE + 1]; + +SpriteBatch::SpriteBatch(GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + m_graphicsDevice = graphicsDevice; + m_shader = NULL; + + // TODO: default size of 1 is best? + m_currentSpritePointer = 0; + + // size vertices and texture storage to match m_currentSpriteCapacity + // HACK: we initialize the buffer to have a size of "1" simply because we + // can't use a size of 0 with the current VertexBuffer implementation + m_vertices = new VertexBuffer(BUFFEROBJECT_USAGE_STREAM); + ASSERT(m_vertices != NULL); + m_vertices->AddAttribute(VERTEX_POS_2D); + m_vertices->AddAttribute(VERTEX_COLOR); + m_vertices->AddAttribute(VERTEX_TEXCOORD); + m_vertices->Create(1); + + m_entities.reserve(1); + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + m_renderState->SetDepthTesting(FALSE); + + m_blendState = new BLENDSTATE_ALPHABLEND; + ASSERT(m_blendState != NULL); + + m_begunRendering = FALSE; + + m_isRenderStateOverridden = FALSE; + m_isBlendStateOverridden = FALSE; + + m_isClipping = FALSE; +} + +SpriteBatch::~SpriteBatch() +{ + STACK_TRACE; + SAFE_DELETE(m_vertices); + SAFE_DELETE(m_renderState); + SAFE_DELETE(m_blendState); +} + +void SpriteBatch::InternalBegin(const RenderState *renderState, const BlendState *blendState, SpriteShader *shader) +{ + STACK_TRACE; + ASSERT(m_begunRendering == FALSE); + + // keep these around for any 3d -> 2d coordinate projection we may need to do + // (since we're switching to a 2d orthographic projection mode next) + m_previousProjection = m_graphicsDevice->GetViewContext()->GetProjectionMatrix(); + m_previousModelview = m_graphicsDevice->GetViewContext()->GetModelViewMatrix(); + + if (shader == NULL) + m_shader = m_graphicsDevice->GetSprite2DShader(); + else + { + ASSERT(shader->IsReadyForUse() == TRUE); + m_shader = shader; + } + + if (renderState != NULL) + { + m_isRenderStateOverridden = TRUE; + m_overrideRenderState = *renderState; + } + else + m_isRenderStateOverridden = FALSE; + + if (blendState != NULL) + { + m_isBlendStateOverridden = TRUE; + m_overrideBlendState = *blendState; + } + else + m_isBlendStateOverridden = FALSE; + + m_currentSpritePointer = 0; + m_begunRendering = TRUE; + m_vertices->MoveToStart(); +} + +void SpriteBatch::Begin(SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(NULL, NULL, shader); +} + +void SpriteBatch::Begin(const RenderState &renderState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(&renderState, NULL, shader); +} + +void SpriteBatch::Begin(const BlendState &blendState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(NULL, &blendState, shader); +} + +void SpriteBatch::Begin(const RenderState &renderState, const BlendState &blendState, SpriteShader *shader) +{ + STACK_TRACE; + InternalBegin(&renderState, &blendState, shader); +} + +void SpriteBatch::Render(const Texture *texture, int16_t x, int16_t y, const Color &color) +{ + STACK_TRACE; + y = FixYCoord(y, texture->GetHeight()); + AddSprite(texture, x, y, x + texture->GetWidth(), y + texture->GetHeight(), 0, 0, texture->GetWidth(), texture->GetHeight(), color); +} + +void SpriteBatch::Render(const Texture *texture, int16_t x, int16_t y, uint16_t width, uint16_t height, const Color &color) +{ + STACK_TRACE; + y = FixYCoord(y, height); + AddSprite(texture, x, y, x + width, y + height, 0, 0, width, height, color); +} + +void SpriteBatch::Render(const Texture *texture, int16_t x, int16_t y, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + y = FixYCoord(y, texture->GetHeight()); + AddSprite(texture, x, y, x + texture->GetWidth(), y + texture->GetHeight(), texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); +} + +void SpriteBatch::Render(const Texture *texture, int16_t x, int16_t y, uint16_t width, uint16_t height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + y = FixYCoord(y, height); + AddSprite(texture, x, y, x + width, y + height, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); +} + +void SpriteBatch::Render(const Texture *texture, const Vector3 &worldPosition, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + screenCoordinates.x -= texture->GetWidth() / 2; + screenCoordinates.y -= texture->GetHeight() / 2; + + Render(texture, screenCoordinates.x, screenCoordinates.y, color); +} + +void SpriteBatch::Render(const Texture *texture, const Vector3 &worldPosition, uint16_t width, uint16_t height, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + screenCoordinates.x -= width / 2; + screenCoordinates.y -= height / 2; + + Render(texture, screenCoordinates.x, screenCoordinates.y, width, height, color); +} + +void SpriteBatch::Render(const Texture *texture, const Vector3 &worldPosition, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + screenCoordinates.x -= texture->GetWidth() / 2; + screenCoordinates.y -= texture->GetHeight() / 2; + + Render(texture, screenCoordinates.x, screenCoordinates.y, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); +} + +void SpriteBatch::Render(const Texture *texture, const Vector3 &worldPosition, uint16_t width, uint16_t height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + screenCoordinates.x -= width / 2; + screenCoordinates.y -= height / 2; + + Render(texture, screenCoordinates.x, screenCoordinates.y, width, height, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); +} + +void SpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, int16_t x, int16_t y, const Color &color) +{ + STACK_TRACE; + const RectF *texCoords = &atlas->GetTile(index).texCoords; + const Rect *tileSize = &atlas->GetTile(index).dimensions; + const Texture *texture = atlas->GetTexture(); + + y = FixYCoord(y, (uint16_t)tileSize->GetHeight()); + AddSprite(texture, x, y, x + tileSize->GetWidth(), y + tileSize->GetHeight(), texCoords->left, texCoords->top, texCoords->right, texCoords->bottom, color); +} + +void SpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, int16_t x, int16_t y, uint16_t width, uint16_t height, const Color &color) +{ + STACK_TRACE; + const RectF *texCoords = &atlas->GetTile(index).texCoords; + const Texture *texture = atlas->GetTexture(); + + y = FixYCoord(y, height); + AddSprite(texture, x, y, x + width, y + height, texCoords->left, texCoords->top, texCoords->right, texCoords->bottom, color); +} + +void SpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &worldPosition, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + const TextureAtlasTile &tile = atlas->GetTile(index); + screenCoordinates.x -= tile.dimensions.GetWidth() / 2; + screenCoordinates.y -= tile.dimensions.GetHeight() / 2; + + Render(atlas, index, screenCoordinates.x, screenCoordinates.y, color); +} + +void SpriteBatch::Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &worldPosition, uint16_t width, uint16_t height, const Color &color) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + screenCoordinates.x -= width / 2; + screenCoordinates.y -= height / 2; + + Render(atlas, index, screenCoordinates.x, screenCoordinates.y, width, height, color); +} + +void SpriteBatch::Render(const SpriteFont *font, int16_t x, int16_t y, const Color &color, const char *text) +{ + STACK_TRACE; + size_t textLength = strlen(text); + + y = FixYCoord(y, (uint16_t)font->GetLetterHeight()); + + int16_t drawX = x; + int16_t drawY = y; + + for (size_t i = 0; i < textLength; ++i) + { + char c = text[i]; + if (c == '\n') + { + // new line + drawX = x; + drawY -= font->GetLetterHeight(); + } + else + { + const TextureAtlasTile &glyph = font->GetGlyph(c); + + AddSprite( + font->GetTexture(), + drawX, drawY, drawX + glyph.dimensions.GetWidth(), drawY + glyph.dimensions.GetHeight(), + glyph.texCoords.left, glyph.texCoords.top, glyph.texCoords.right, glyph.texCoords.bottom, + color + ); + + drawX += glyph.dimensions.GetWidth(); + } + } +} + +void SpriteBatch::Render(const SpriteFont *font, int16_t x, int16_t y, const Color &color, float scale, const char *text) +{ + STACK_TRACE; + size_t textLength = strlen(text); + + float scaledLetterHeight = (float)font->GetLetterHeight() * scale; + + y = (int16_t)FixYCoord(y, scaledLetterHeight); + + float drawX = (float)x; + float drawY = (float)y; + + for (size_t i = 0; i < textLength; ++i) + { + char c = text[i]; + if (c == '\n') + { + // new line + drawX = x; + drawY -= scaledLetterHeight; + } + else + { + const TextureAtlasTile &glyph = font->GetGlyph(c); + + float scaledGlyphWidth = (float)glyph.dimensions.GetWidth() * scale; + float scaledGlyphHeight = (float)glyph.dimensions.GetHeight() * scale; + + AddSprite( + font->GetTexture(), + drawX, drawY, drawX + scaledGlyphWidth, drawY + scaledGlyphHeight, + glyph.texCoords.left, glyph.texCoords.top, glyph.texCoords.right, glyph.texCoords.bottom, + color + ); + + drawX += scaledGlyphWidth; + } + } +} + +void SpriteBatch::Render(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, const char *text) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + uint16_t textWidth = 0; + uint16_t textHeight = 0; + font->MeasureString(&textWidth, &textHeight, text); + + screenCoordinates.x -= textWidth / 2; + screenCoordinates.y -= textHeight / 2; + + Render(font, screenCoordinates.x, screenCoordinates.y, color, text); +} + +void SpriteBatch::Render(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, float scale, const char *text) +{ + STACK_TRACE; + Point2 screenCoordinates = m_graphicsDevice->GetViewContext()->GetCamera()->Project(worldPosition, m_previousModelview, m_previousProjection); + + uint16_t textWidth = 0; + uint16_t textHeight = 0; + font->MeasureString(&textWidth, &textHeight, scale, text); + + screenCoordinates.x -= textWidth / 2; + screenCoordinates.y -= textHeight / 2; + + Render(font, screenCoordinates.x, screenCoordinates.y, color, scale, text); +} + +void SpriteBatch::Printf(const SpriteFont *font, int16_t x, int16_t y, const Color &color, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__spriteBatch_printfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, x, y, color, __spriteBatch_printfBuffer); +} + +void SpriteBatch::Printf(const SpriteFont *font, int16_t x, int16_t y, const Color &color, float scale, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__spriteBatch_printfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, x, y, color, scale, __spriteBatch_printfBuffer); +} + +void SpriteBatch::Printf(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__spriteBatch_printfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, worldPosition, color, __spriteBatch_printfBuffer); +} + +void SpriteBatch::Printf(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, float scale, const char *format, ...) +{ + STACK_TRACE; + va_list args; + va_start(args, format); + vsnprintf(__spriteBatch_printfBuffer, PRINTF_BUFFER_SIZE, format, args); + va_end(args); + + Render(font, worldPosition, color, scale, __spriteBatch_printfBuffer); +} + +void SpriteBatch::RenderLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, const Color &color) +{ + STACK_TRACE; + y1 = FixYCoord(y1, (uint16_t)1); + y2 = FixYCoord(y2, (uint16_t)1); + + AddLine(x1, y1, x2, y2, color); +} + +void SpriteBatch::RenderBox(int16_t left, int16_t top, int16_t right, int16_t bottom, const Color &color) +{ + STACK_TRACE; + uint16_t height = bottom - top; + top = FixYCoord(top, height); + bottom = top + height; + + AddLine(left, top, left, bottom, color); + AddLine(left, bottom, right, bottom, color); + AddLine(right, top, right, bottom, color); + AddLine(left, top, right, top, color); +} + +void SpriteBatch::RenderBox(const Rect &rect, const Color &color) +{ + STACK_TRACE; + int16_t left = (int16_t)rect.left; + int16_t top = (int16_t)rect.top; + int16_t right = (int16_t)rect.right; + int16_t bottom = (int16_t)rect.bottom; + + uint16_t height = bottom - top; + top = FixYCoord(top, height); + bottom = top + height; + + AddLine(left, top, left, bottom, color); + AddLine(left, bottom, right, bottom, color); + AddLine(right, top, right, bottom, color); + AddLine(left, top, right, top, color); +} + +void SpriteBatch::RenderFilledBox(int16_t left, int16_t top, int16_t right, int16_t bottom, const Color &color) +{ + STACK_TRACE; + uint16_t height = bottom - top; + top = FixYCoord(top, height); + bottom = top + height; + + AddFilledBox(left, top, right, bottom, color); +} + +void SpriteBatch::RenderFilledBox(const Rect &rect, const Color &color) +{ + STACK_TRACE; + int16_t left = (int16_t)rect.left; + int16_t top = (int16_t)rect.top; + int16_t right = (int16_t)rect.right; + int16_t bottom = (int16_t)rect.bottom; + + uint16_t height = bottom - top; + top = FixYCoord(top, height); + bottom = top + height; + + AddFilledBox(left, top, right, bottom, color); +} + +void SpriteBatch::AddSprite(const Texture *texture, int16_t destLeft, int16_t destTop, int16_t destRight, int16_t destBottom, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + uint16_t width = sourceRight - sourceLeft; + ASSERT(width > 0); + uint16_t height = sourceBottom - sourceTop; + ASSERT(height > 0); + float texLeft = sourceLeft / (float)width; + float texTop = sourceTop / (float)height; + float texRight = sourceRight / (float)width; + float texBottom = sourceBottom / (float)height; + float destLeftF = (float)destLeft; + float destTopF = (float)destTop; + float destRightF = (float)destRight; + float destBottomF = (float)destBottom; + + if (m_isClipping) + { + if (!ClipSpriteCoords(destLeftF, destTopF, destRightF, destBottomF, texLeft, texTop, texRight, texBottom)) + return; + } + + CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_SPRITE); + SetSpriteInfo(m_currentSpritePointer, texture, destLeftF, destTopF, destRightF, destBottomF, texLeft, texTop, texRight, texBottom, color); + ++m_currentSpritePointer; +} + +void SpriteBatch::AddSprite(const Texture *texture, int16_t destLeft, int16_t destTop, int16_t destRight, int16_t destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + float destLeftF = (float)destLeft; + float destTopF = (float)destTop; + float destRightF = (float)destRight; + float destBottomF = (float)destBottom; + + if (m_isClipping) + { + if (!ClipSpriteCoords(destLeftF, destTopF, destRightF, destBottomF, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom)) + return; + } + + CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_SPRITE); + SetSpriteInfo(m_currentSpritePointer, texture, destLeftF, destTopF, destRightF, destBottomF, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); + ++m_currentSpritePointer; +} + +void SpriteBatch::AddSprite(const Texture *texture, float destLeft, float destTop, float destRight, float destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + if (m_isClipping) + { + if (!ClipSpriteCoords(destLeft, destTop, destRight, destBottom, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom)) + return; + } + + CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_SPRITE); + SetSpriteInfo(m_currentSpritePointer, texture, destLeft, destTop, destRight, destBottom, texCoordLeft, texCoordTop, texCoordRight, texCoordBottom, color); + ++m_currentSpritePointer; +} + +BOOL SpriteBatch::ClipSpriteCoords(float &left, float &top, float &right, float &bottom, float &texCoordLeft, float &texCoordTop, float &texCoordRight, float &texCoordBottom) +{ + STACK_TRACE; + + // check for completely out of bounds scenarios first + if (left >= m_clipRegion.right) + return FALSE; + if (right < m_clipRegion.left) + return FALSE; + if (top >= m_clipRegion.bottom) + return FALSE; + if (bottom < m_clipRegion.top) + return FALSE; + + float clippedLeft = left; + float clippedTop = top; + float clippedRight = right; + float clippedBottom = bottom; + float clippedTexCoordLeft = texCoordLeft; + float clippedTexCoordTop = texCoordTop; + float clippedTexCoordRight = texCoordRight; + float clippedTexCoordBottom = texCoordBottom; + + if (clippedLeft < m_clipRegion.left) + { + clippedLeft = m_clipRegion.left; + float t = InverseLerp(left, right, clippedLeft); + clippedTexCoordLeft = Lerp(texCoordLeft, texCoordRight, t); + } + if (clippedRight > m_clipRegion.right) + { + clippedRight = m_clipRegion.right; + float t = InverseLerp(right, left, clippedRight); + clippedTexCoordRight = Lerp(texCoordRight, texCoordLeft, t); + } + if (clippedTop < m_clipRegion.top) + { + clippedTop = m_clipRegion.top; + float t = InverseLerp(top, bottom, clippedTop); + clippedTexCoordBottom = Lerp(texCoordBottom, texCoordTop, t); + } + if (clippedBottom > m_clipRegion.bottom) + { + clippedBottom = m_clipRegion.bottom; + float t = InverseLerp(bottom, top, clippedBottom); + clippedTexCoordTop = Lerp(texCoordTop, texCoordBottom, t); + } + + left = clippedLeft; + top = clippedTop; + right = clippedRight; + bottom = clippedBottom; + texCoordLeft = clippedTexCoordLeft; + texCoordTop = clippedTexCoordTop; + texCoordRight = clippedTexCoordRight; + texCoordBottom = clippedTexCoordBottom; + + return TRUE; +} + +void SpriteBatch::SetSpriteInfo(uint32_t spriteIndex, const Texture *texture, float destLeft, float destTop, float destRight, float destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color) +{ + STACK_TRACE; + uint32_t base = m_vertices->GetCurrentPosition(); + + m_vertices->SetPosition2(base, destLeft, destTop); + m_vertices->SetPosition2(base + 1, destRight, destTop); + m_vertices->SetPosition2(base + 2, destRight, destBottom); + m_vertices->SetPosition2(base + 3, destLeft, destTop); + m_vertices->SetPosition2(base + 4, destRight, destBottom); + m_vertices->SetPosition2(base + 5, destLeft, destBottom); + + m_vertices->SetTexCoord(base, texCoordLeft, texCoordBottom); + m_vertices->SetTexCoord(base + 1, texCoordRight, texCoordBottom); + m_vertices->SetTexCoord(base + 2, texCoordRight, texCoordTop); + m_vertices->SetTexCoord(base + 3, texCoordLeft, texCoordBottom); + m_vertices->SetTexCoord(base + 4, texCoordRight, texCoordTop); + m_vertices->SetTexCoord(base + 5, texCoordLeft, texCoordTop); + + m_vertices->SetColor(base, color); + m_vertices->SetColor(base + 1, color); + m_vertices->SetColor(base + 2, color); + m_vertices->SetColor(base + 3, color); + m_vertices->SetColor(base + 4, color); + m_vertices->SetColor(base + 5, color); + + // move ahead past this sprite's vertices, so we're ready for the next one + m_vertices->Move(6); + + // keep info about this entity we just added vertices for + SpriteBatchEntity &entity = m_entities[spriteIndex]; + entity.texture = texture; + entity.type = SPRITEBATCH_ENTITY_SPRITE; + entity.firstVertex = base; + entity.lastVertex = base + 5; +} + +void SpriteBatch::AddLine(float x1, float y1, float x2, float y2, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + if (m_isClipping) + { + if (!ClipLineCoords(x1, y1, x2, y2)) + return; + } + + CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_LINE); + SetLineInfo(m_currentSpritePointer, x1, y1, x2, y2, color); + ++m_currentSpritePointer; +} + +void SpriteBatch::SetLineInfo(uint32_t spriteIndex, float x1, float y1, float x2, float y2, const Color &color) +{ + STACK_TRACE; + uint32_t base = m_vertices->GetCurrentPosition(); + + m_vertices->SetPosition2(base, x1, y1); + m_vertices->SetPosition2(base + 1, x2, y2); + + // not used + m_vertices->SetTexCoord(base, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 1, 0.0f, 0.0f); + + m_vertices->SetColor(base, color); + m_vertices->SetColor(base + 1, color); + + // move ahead past this sprite's vertices, so we're ready for the next one + m_vertices->Move(2); + + // keep info about this entity we just added vertices for + SpriteBatchEntity &entity = m_entities[spriteIndex]; + entity.texture = NULL; + entity.type = SPRITEBATCH_ENTITY_LINE; + entity.firstVertex = base; + entity.lastVertex = base + 1; +} + +BOOL SpriteBatch::ClipLineCoords(float &x1, float &y1, float &x2, float &y2) +{ + STACK_TRACE; + + // TODO: implementation + + return TRUE; +} + +void SpriteBatch::AddFilledBox(float left, float top, float right, float bottom, const Color &color) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + if (m_isClipping) + { + if (!ClipFilledBoxCoords(left, top, right, bottom)) + return; + } + + CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_FILLEDBOX); + SetFilledBoxInfo(m_currentSpritePointer, left, top, right, bottom, color); + ++m_currentSpritePointer; +} + +void SpriteBatch::SetFilledBoxInfo(uint32_t spriteIndex, float left, float top, float right, float bottom, const Color &color) +{ + STACK_TRACE; + uint32_t base = m_vertices->GetCurrentPosition(); + + m_vertices->SetPosition2(base, left, top); + m_vertices->SetPosition2(base + 1, right, top); + m_vertices->SetPosition2(base + 2, right, bottom); + m_vertices->SetPosition2(base + 3, left, top); + m_vertices->SetPosition2(base + 4, right, bottom); + m_vertices->SetPosition2(base + 5, left, bottom); + + // not used + m_vertices->SetTexCoord(base, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 1, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 2, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 3, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 4, 0.0f, 0.0f); + m_vertices->SetTexCoord(base + 5, 0.0f, 0.0f); + + m_vertices->SetColor(base, color); + m_vertices->SetColor(base + 1, color); + m_vertices->SetColor(base + 2, color); + m_vertices->SetColor(base + 3, color); + m_vertices->SetColor(base + 4, color); + m_vertices->SetColor(base + 5, color); + + // move ahead past this sprite's vertices, so we're ready for the next one + m_vertices->Move(6); + + // keep info about this entity we just added vertices for + SpriteBatchEntity &entity = m_entities[spriteIndex]; + entity.texture = NULL; + entity.type = SPRITEBATCH_ENTITY_FILLEDBOX; + entity.firstVertex = base; + entity.lastVertex = base + 5; +} + +BOOL SpriteBatch::ClipFilledBoxCoords(float &left, float &top, float &right, float &bottom) +{ + STACK_TRACE; + + // check for completely out of bounds scenarios first + if (left >= m_clipRegion.right) + return FALSE; + if (right < m_clipRegion.left) + return FALSE; + if (top >= m_clipRegion.bottom) + return FALSE; + if (bottom < m_clipRegion.top) + return FALSE; + + float clippedLeft = left; + float clippedTop = top; + float clippedRight = right; + float clippedBottom = bottom; + + if (clippedLeft < m_clipRegion.left) + clippedLeft = m_clipRegion.left; + if (clippedRight > m_clipRegion.right) + clippedRight = m_clipRegion.right; + if (clippedTop < m_clipRegion.top) + clippedTop = m_clipRegion.top; + if (clippedBottom > m_clipRegion.bottom) + clippedBottom = m_clipRegion.bottom; + + left = clippedLeft; + top = clippedTop; + right = clippedRight; + bottom = clippedBottom; + + return TRUE; +} + +void SpriteBatch::End() +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + + // don't do anything if nothing is to be rendered! + if (m_currentSpritePointer == 0) + { + // should do this regardless if we're rendering anything or not + ClearClipRegion(); + m_begunRendering = FALSE; + return; + } + + if (m_isRenderStateOverridden) + m_overrideRenderState.Apply(); + else + m_renderState->Apply(); + if (m_isBlendStateOverridden) + m_overrideBlendState.Apply(); + else + m_blendState->Apply(); + + m_graphicsDevice->BindShader(m_shader); + m_shader->SetModelViewMatrix(IDENTITY_MATRIX); + m_shader->SetProjectionMatrix(m_graphicsDevice->GetViewContext()->GetOrthographicProjectionMatrix()); + RenderQueue(); + m_graphicsDevice->UnbindShader(); + + // ClearClipRegion expects that m_begunRendering == TRUE, so we need to set that last + ClearClipRegion(); + m_begunRendering = FALSE; +} + +void SpriteBatch::RenderQueue() +{ + STACK_TRACE; + m_graphicsDevice->BindVertexBuffer(m_vertices); + + const SpriteBatchEntity *firstEntity = &m_entities[0]; + const SpriteBatchEntity *lastEntity = &m_entities[0]; + + for (uint32_t i = 0; i < m_currentSpritePointer; ++i) + { + if (lastEntity->type != m_entities[i].type) + { + // if the next type is different then the last range's type, then + // we need to render the last range now + RenderQueueRange(firstEntity, lastEntity); + + // switch to the new range with this new type + firstEntity = &m_entities[i]; + } + else + { + if (lastEntity->texture != m_entities[i].texture) + { + // if the next texture is different then the last range's + // texture, then we need to render the last range now + RenderQueueRange(firstEntity, lastEntity); + + // switch to the new range with this new texture + firstEntity = &m_entities[i]; + } + } + + lastEntity = &m_entities[i]; + } + // we'll have one last range to render at this point (the loop would have + // ended before it was caught by the checks inside the loop) + RenderQueueRange(firstEntity, lastEntity); + + m_graphicsDevice->UnbindVertexBuffer(); +} + +void SpriteBatch::RenderQueueRange(const SpriteBatchEntity *firstEntity, const SpriteBatchEntity *lastEntity) +{ + STACK_TRACE; + uint32_t startVertex = firstEntity->firstVertex; + uint32_t lastVertex = lastEntity->lastVertex + 1; + + if (lastEntity->texture != NULL) + { + m_graphicsDevice->BindTexture(lastEntity->texture); + m_shader->SetTextureHasAlphaOnly(lastEntity->texture->GetFormat() == TEXTURE_FORMAT_ALPHA); + } + else + // HACK: probably better idea to use a RenderState to turn texturing off + m_graphicsDevice->UnbindTexture(); + + switch (lastEntity->type) + { + case SPRITEBATCH_ENTITY_SPRITE: + m_graphicsDevice->RenderTriangles(startVertex, (lastVertex - startVertex) / 3); + break; + case SPRITEBATCH_ENTITY_LINE: + m_graphicsDevice->RenderLines(startVertex, (lastVertex - startVertex) / 2); + break; + case SPRITEBATCH_ENTITY_FILLEDBOX: + m_graphicsDevice->RenderTriangles(startVertex, (lastVertex - startVertex) / 3); + break; + } +} + +void SpriteBatch::CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_TYPE type) +{ + STACK_TRACE; + // HACK: the assumption is made here that this will never expand the buffers + // by an amount that could be used to store more then one entity at a + // time. This is because we use std::vector::push_back to expand the + // entity object storage by only one. + + uint32_t verticesRequired = GetVerticesRequiredFor(type); + if (m_vertices->GetRemainingSpace() < verticesRequired) + { + // need to add more space for a new entity of the specified type to fit + m_vertices->Extend(verticesRequired - m_vertices->GetRemainingSpace()); + ASSERT(m_vertices->GetRemainingSpace() >= verticesRequired); + + m_entities.push_back(SpriteBatchEntity()); + ASSERT(m_currentSpritePointer < m_entities.size()); + } +} + +inline uint32_t SpriteBatch::GetVerticesRequiredFor(SPRITEBATCH_ENTITY_TYPE type) +{ + uint32_t numVerticesRequired = 0; + switch (type) + { + case SPRITEBATCH_ENTITY_SPRITE: numVerticesRequired = 6; break; + case SPRITEBATCH_ENTITY_LINE: numVerticesRequired = 2; break; + case SPRITEBATCH_ENTITY_FILLEDBOX: numVerticesRequired = 6; break; + } + + ASSERT(numVerticesRequired != 0); + return numVerticesRequired; +} + +inline int16_t SpriteBatch::FixYCoord(int16_t y, uint16_t sourceHeight) const +{ + return m_graphicsDevice->GetViewContext()->GetViewportHeight() - y - sourceHeight; +} + +inline float SpriteBatch::FixYCoord(int16_t y, float sourceHeight) const +{ + return (float)m_graphicsDevice->GetViewContext()->GetViewportHeight() - (float)y - sourceHeight; +} + +void SpriteBatch::SetClipRegion(const Rect &rect) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + m_isClipping = TRUE; + + int32_t fixedTop = ((int32_t)m_graphicsDevice->GetViewContext()->GetViewportHeight() - rect.top - rect.GetHeight()); + int32_t fixedBottom = fixedTop + rect.GetHeight(); + + m_clipRegion.left = (float)rect.left; + m_clipRegion.top = (float)fixedTop; + m_clipRegion.right = (float)rect.right; + m_clipRegion.bottom = (float)fixedBottom; +} + +void SpriteBatch::SetClipRegion(int16_t left, int16_t top, int16_t right, int16_t bottom) +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + m_isClipping = TRUE; + + int16_t height = bottom - top; + int16_t fixedTop = (m_graphicsDevice->GetViewContext()->GetViewportHeight() - top - height); + int16_t fixedBottom = fixedTop + height; + + m_clipRegion.left = (float)left; + m_clipRegion.top = (float)fixedTop; + m_clipRegion.right = (float)right; + m_clipRegion.bottom = (float)fixedBottom; +} + +void SpriteBatch::ClearClipRegion() +{ + STACK_TRACE; + ASSERT(m_begunRendering == TRUE); + m_isClipping = FALSE; +} + diff --git a/src/framework/graphics/spritebatch.h b/src/framework/graphics/spritebatch.h new file mode 100644 index 0000000..e0bac9e --- /dev/null +++ b/src/framework/graphics/spritebatch.h @@ -0,0 +1,422 @@ +#ifndef __FRAMEWORK_GRAPHICS_SPRITEBATCH_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SPRITEBATCH_H_INCLUDED__ + +#include "../common.h" +#include "blendstate.h" +#include "color.h" +#include "renderstate.h" +#include "../math/matrix4x4.h" +#include "../math/rectf.h" +#include + +class GraphicsDevice; +class SpriteFont; +class SpriteShader; +class Texture; +class TextureAtlas; +class VertexBuffer; +struct Rect; +struct Vector3; + +enum SPRITEBATCH_ENTITY_TYPE +{ + SPRITEBATCH_ENTITY_SPRITE, + SPRITEBATCH_ENTITY_LINE, + SPRITEBATCH_ENTITY_FILLEDBOX +}; + +struct SpriteBatchEntity +{ + const Texture *texture; + SPRITEBATCH_ENTITY_TYPE type; + uint32_t firstVertex; + uint32_t lastVertex; +}; + +/** + * Wrapper for 2D sprite and text rendering. + */ +class SpriteBatch +{ +public: + /** + * Creates a sprite batch object. + * @param graphicsDevice the graphics device to perform rendering with + */ + SpriteBatch(GraphicsDevice *graphicsDevice); + + virtual ~SpriteBatch(); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param renderState custom render state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const RenderState &renderState, SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param blendState custom blend state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const BlendState &blendState, SpriteShader *shader = NULL); + + /** + * Begins a rendering block. All rendering with this object should be + * performed after this and then completed with a call to End(). + * @param renderState custom render state to use for rendering + * @param blendState custom blend state to use for rendering + * @param shader shader to render with, or NULL to use a default shader + */ + void Begin(const RenderState &renderState, const BlendState &blendState, SpriteShader *shader = NULL); + + /** + * Renders a texture as a sprite. + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param color color to tint the texture with + */ + void Render(const Texture *texture, int16_t x, int16_t y, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param color color to tint the texture with + */ + void Render(const Texture *texture, int16_t x, int16_t y, uint16_t width, uint16_t height, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param texCoordLeft left U texture coordinate defining a sub-region of the texture to render + * @param texCoordTop top V texture coordinate defining a sub-region of the texture to render + * @param texCoordRight right U texture coordinate defining a sub-region of the texture to render + * @param texCoordBottom bottom V texture coordinate defining a sub-region of the texture to render + * @param color color to tint the texture with + */ + void Render(const Texture *texture, int16_t x, int16_t y, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param texCoordLeft left U texture coordinate defining a sub-region of the texture to render + * @param texCoordTop top V texture coordinate defining a sub-region of the texture to render + * @param texCoordRight right U texture coordinate defining a sub-region of the texture to render + * @param texCoordBottom bottom V texture coordinate defining a sub-region of the texture to render + * @param color color to tint the texture with + */ + void Render(const Texture *texture, int16_t x, int16_t y, uint16_t width, uint16_t height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. The given world position will be + * projected to 2D screen coordinates where the texture will be centered + * on and rendered at. + * @param worldPosition 3D world position to render at + * @param color color to tint the texture with + */ + void Render(const Texture *texture, const Vector3 &worldPosition, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. The given world position will be + * projected to 2D screen coordinates where the texture will be centered + * on and rendered at. + * @param worldPosition 3D world position to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param color color to tint the texture with + */ + void Render(const Texture *texture, const Vector3 &worldPosition, uint16_t width, uint16_t height, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. The given world position will be + * projected to 2D screen coordinates where the texture will be centered + * on and rendered at. + * @param worldPosition 3D world position to render at + * @param texCoordLeft left U texture coordinate defining a sub-region of the texture to render + * @param texCoordTop top V texture coordinate defining a sub-region of the texture to render + * @param texCoordRight right U texture coordinate defining a sub-region of the texture to render + * @param texCoordBottom bottom V texture coordinate defining a sub-region of the texture to render + * @param color color to tint the texture with + */ + void Render(const Texture *texture, const Vector3 &worldPosition, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color = COLOR_WHITE); + + /** + * Renders a texture as a sprite. The given world position will be + * projected to 2D screen coordinates where the texture will be centered + * on and rendered at. + * @param worldPosition 3D world position to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param texCoordLeft left U texture coordinate defining a sub-region of the texture to render + * @param texCoordTop top V texture coordinate defining a sub-region of the texture to render + * @param texCoordRight right U texture coordinate defining a sub-region of the texture to render + * @param texCoordBottom bottom V texture coordinate defining a sub-region of the texture to render + * @param color color to tint the texture with + */ + void Render(const Texture *texture, const Vector3 &worldPosition, uint16_t width, uint16_t height, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a sprite. + * @param index the index of the sub-texture / tile to render + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, int16_t x, int16_t y, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a sprite. + * @param index the index of the sub-texture / tile to render + * @param x X coordinate to render at + * @param y Y coordinate to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, int16_t x, int16_t y, uint16_t width, uint16_t height, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a sprite. The given + * world position will be projected to 2D screen coordinates where the + * texture will be centered on and rendered at. + * @param index the index of the sub-texture / tile to render + * @param worldPosition 3D world position to render at + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &worldPosition, const Color &color = COLOR_WHITE); + + /** + * Renders a texture atlas sub-texture / tile as a sprite. The given + * world position will be projected to 2D screen coordinates where the + * texture will be centered on and rendered at. + * @param index the index of the sub-texture / tile to render + * @param worldPosition 3D world position to render at + * @param width custom width to scale the texture to during rendering + * @param height custom height to scale the texture to during rendering + * @param color color to tint the texture with + */ + void Render(const TextureAtlas *atlas, uint32_t index, const Vector3 &worldPosition, uint16_t width, uint16_t height, const Color &color = COLOR_WHITE); + + /** + * Renders text as series of sprites. + * @param font the font to render with + * @param x X coordinate to begin rendering at + * @param y Y coordinate to begin rendering at + * @param color the color to render the text in + * @param text the string of text to render + */ + void Render(const SpriteFont *font, int16_t x, int16_t y, const Color &color, const char *text); + + /** + * Renders text as series of sprites. + * @param font the font to render with + * @param x X coordinate to begin rendering at + * @param y Y coordinate to begin rendering at + * @param color the color to render the text in + * @param scale scaling factor to render with + * @param text the string of text to render + */ + void Render(const SpriteFont *font, int16_t x, int16_t y, const Color &color, float scale, const char *text); + + /** + * Renders text as series of sprites. The given world position will be + * projected to 2D screen coordinates where the text will be centered on + * and rendered at. + * @param font the font to render with + * @param worldPosition 3D world position to render at + * @param color the color to render the text in + * @param text the string of text to render + */ + void Render(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, const char *text); + + /** + * Renders text as series of sprites. The given world position will be + * projected to 2D screen coordinates where the text will be centered on + * and rendered at. + * @param font the font to render with + * @param worldPosition 3D world position to render at + * @param color the color to render the text in + * @param scale scaling factor to render with + * @param text the string of text to render + */ + void Render(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, float scale, const char *text); + + /** + * Renders formatted text as series of sprites. + * @param font the font to render with + * @param x X coordinate to begin rendering at + * @param y Y coordinate to begin rendering at + * @param color the color to render the text in + * @param format the string of text to render + */ + void Printf(const SpriteFont *font, int16_t x, int16_t y, const Color &color, const char *format, ...); + + /** + * Renders formatted text as series of sprites. + * @param font the font to render with + * @param x X coordinate to begin rendering at + * @param y Y coordinate to begin rendering at + * @param color the color to render the text in + * @param scale scaling factor to render with + * @param format the string of text to render + */ + void Printf(const SpriteFont *font, int16_t x, int16_t y, const Color &color, float scale, const char *format, ...); + + /** + * Renders formatted text as series of sprites. The given world position + * will be projected to 2D screen coordinates where the text will be + * centered on and rendered at. + * @param font the font to render with + * @param worldPosition 3D world position to render at + * @param color the color to render the text in + * @param format the string of text to render + */ + void Printf(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, const char *format, ...); + + /** + * Renders formatted text as series of sprites. The given world position + * will be projected to 2D screen coordinates where the text will be + * centered on and rendered at. + * @param font the font to render with + * @param worldPosition 3D world position to render at + * @param color the color to render the text in + * @param scale scaling factor to render with + * @param format the string of text to render + */ + void Printf(const SpriteFont *font, const Vector3 &worldPosition, const Color &color, float scale, const char *format, ...); + + /** + * Renders a line between two points. + * @param x1 X coordinate of the first point + * @param y1 Y coordinate of the first point + * @param x2 X coordinate of the second point + * @param y2 Y coordinate of the second point + * @param color the color to render the line with + */ + void RenderLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, const Color &color); + + /** + * Renders a box. + * @param left left X coordinate of the box + * @param top top Y coordinate of the box + * @param right right X coordinate of the box + * @param bottom bottom Y coordinate of the box + * @param color the color to render the box with + */ + void RenderBox(int16_t left, int16_t top, int16_t right, int16_t bottom, const Color &color); + + /** + * Renders a box. + * @param rect the position and dimensions of the box + * @param color the color to render the box with + */ + void RenderBox(const Rect &rect, const Color &color); + + /** + * Renders a filled box. + * @param left left X coordinate of the box + * @param top top Y coordinate of the box + * @param right right X coordinate of the box + * @param bottom bottom Y coordinate of the box + * @param color the color to render the box with + */ + void RenderFilledBox(int16_t left, int16_t top, int16_t right, int16_t bottom, const Color &color); + + /** + * Renders a filled box. + * @param rect the position and dimensions of the box + * @param color the color to render the box with + */ + void RenderFilledBox(const Rect &rect, const Color &color); + + /** + * Ends a rendering block, flushing out all rendering calls made + * since the Begin() call to the video card. + */ + void End(); + + /** + * Defines a clipping region which all subsequent rendering will be + * clipped to. + * @param rect the clipping region + */ + void SetClipRegion(const Rect &rect); + + /** + * Defines a clipping region which all subsequent rendering will be + * clipped to. + * @param left left X coordinate of the clipping region + * @param top top Y coordinate of the clipping region + * @param right right X coordinate of the clipping region + * @param bottom bottom Y coordinate of the clipping region + */ + void SetClipRegion(int16_t left, int16_t top, int16_t right, int16_t bottom); + + /** + * Removes the clipping region. All subsequent rendering will no longer + * be clipped. + */ + void ClearClipRegion(); + +private: + void InternalBegin(const RenderState *renderState, const BlendState *blendState, SpriteShader *shader); + + void AddSprite(const Texture *texture, int16_t destLeft, int16_t destTop, int16_t destRight, int16_t destBottom, uint16_t sourceLeft, uint16_t sourceTop, uint16_t sourceRight, uint16_t sourceBottom, const Color &color); + void AddSprite(const Texture *texture, int16_t destLeft, int16_t destTop, int16_t destRight, int16_t destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + void AddSprite(const Texture *texture, float destLeft, float destTop, float destRight, float destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + BOOL ClipSpriteCoords(float &left, float &top, float &right, float &bottom, float &texCoordLeft, float &texCoordTop, float &texCoordRight, float &texCoordBottom); + void SetSpriteInfo(uint32_t spriteIndex, const Texture *texture, float destLeft, float destTop, float destRight, float destBottom, float texCoordLeft, float texCoordTop, float texCoordRight, float texCoordBottom, const Color &color); + + void AddLine(float x1, float y1, float x2, float y2, const Color &color); + void SetLineInfo(uint32_t spriteIndex, float x1, float y1, float x2, float y2, const Color &color); + BOOL ClipLineCoords(float &x1, float &y1, float &x2, float &y2); + + void AddFilledBox(float left, float top, float right, float bottom, const Color &color); + void SetFilledBoxInfo(uint32_t spriteIndex, float left, float top, float right, float bottom, const Color &color); + BOOL ClipFilledBoxCoords(float &left, float &top, float &right, float &bottom); + + void RenderQueue(); + void RenderQueueRange(const SpriteBatchEntity *firstEntity, const SpriteBatchEntity *lastEntity); + + void CheckForNewSpriteSpace(SPRITEBATCH_ENTITY_TYPE type); + + uint32_t GetVerticesRequiredFor(SPRITEBATCH_ENTITY_TYPE type); + int16_t FixYCoord(int16_t y, uint16_t sourceHeight) const; + float FixYCoord(int16_t y, float sourceHeight) const; + + GraphicsDevice *m_graphicsDevice; + SpriteShader *m_shader; + RenderState *m_renderState; + BlendState *m_blendState; + BOOL m_isRenderStateOverridden; + RenderState m_overrideRenderState; + BOOL m_isBlendStateOverridden; + BlendState m_overrideBlendState; + VertexBuffer *m_vertices; + stl::vector m_entities; + uint32_t m_currentSpritePointer; + Matrix4x4 m_previousProjection; + Matrix4x4 m_previousModelview; + BOOL m_isClipping; + RectF m_clipRegion; + + BOOL m_begunRendering; +}; + +#endif diff --git a/src/framework/graphics/spritefont.cpp b/src/framework/graphics/spritefont.cpp new file mode 100644 index 0000000..fce9ca7 --- /dev/null +++ b/src/framework/graphics/spritefont.cpp @@ -0,0 +1,139 @@ +#include "../debug.h" + +#include "spritefont.h" + +#include +#include +#include +#include + +#include "graphicsdevice.h" +#include "texture.h" +#include "textureatlas.h" + +SpriteFont::SpriteFont() + : Content() +{ + m_size = 0; + m_texture = NULL; + m_glyphs = NULL; + m_letterHeight = 0; +} + +SpriteFont::~SpriteFont() +{ + STACK_TRACE; + SAFE_DELETE(m_glyphs); + SAFE_DELETE(m_texture); +} + +void SpriteFont::Load(Texture *texture, TextureAtlas *glyphs, uint8_t size) +{ + STACK_TRACE; + m_texture = texture; + m_glyphs = glyphs; + m_size = size; + m_letterHeight = GetGlyph(' ').dimensions.GetHeight(); +} + +void SpriteFont::OnLostContext() +{ + STACK_TRACE; + SAFE_DELETE(m_glyphs); + m_letterHeight = 0; + SAFE_DELETE(m_texture); +} + +const TextureAtlasTile& SpriteFont::GetGlyph(unsigned char c) const +{ + STACK_TRACE; + if (c < LOW_GLYPH || c > HIGH_GLYPH) + return m_glyphs->GetTile(HIGH_GLYPH - LOW_GLYPH); + else + return m_glyphs->GetTile((int)c - LOW_GLYPH); +} + +void SpriteFont::MeasureString(uint16_t *width, uint16_t *height, const char *format, ...) const +{ + STACK_TRACE; + ASSERT(width != NULL || height != NULL); + static char buffer[8096]; // probably way more then adequate + + va_list args; + va_start(args, format); + vsnprintf(buffer, 8095, format, args); + va_end(args); + + size_t textLength = strlen(buffer); + + uint16_t currentMaxWidth = 0; + uint16_t left = 0; + int numLines = 1; + + for (size_t i = 0; i < textLength; ++i) + { + char c = buffer[i]; + if (c == '\n') + { + // new line + left = 0; + ++numLines; + } + else + { + const TextureAtlasTile &glyph = GetGlyph(c); + left += glyph.dimensions.GetWidth(); + } + + currentMaxWidth = Max(left, currentMaxWidth); + } + + if (width != NULL) + *width = currentMaxWidth; + if (height != NULL) + *height = (uint16_t)(numLines * GetLetterHeight()); +} + +void SpriteFont::MeasureString(uint16_t *width, uint16_t *height, float scale, const char *format, ...) const +{ + STACK_TRACE; + ASSERT(width != NULL || height != NULL); + static char buffer[8096]; // probably way more then adequate + + va_list args; + va_start(args, format); + vsnprintf(buffer, 8095, format, args); + va_end(args); + + size_t textLength = strlen(buffer); + + float scaledLetterHeight = (float)GetLetterHeight() * scale; + + float currentMaxWidth = 0; + float x = 0; + int numLines = 1; + + for (size_t i = 0; i < textLength; ++i) + { + char c = buffer[i]; + if (c == '\n') + { + // new line + x = 0.0f; + ++numLines; + } + else + { + const TextureAtlasTile &glyph = GetGlyph(c); + x += ((float)glyph.dimensions.GetWidth() * scale); + } + + currentMaxWidth = Max(x, currentMaxWidth); + } + + if (width != NULL) + *width = (uint16_t)ceil(currentMaxWidth); + if (height != NULL) + *height = (uint16_t)(numLines * scaledLetterHeight); +} + diff --git a/src/framework/graphics/spritefont.h b/src/framework/graphics/spritefont.h new file mode 100644 index 0000000..88c13bd --- /dev/null +++ b/src/framework/graphics/spritefont.h @@ -0,0 +1,102 @@ +#ifndef __FRAMEWORK_GRAPHICS_SPRITEFONT_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SPRITEFONT_H_INCLUDED__ + +#include "../common.h" +#include "../content/content.h" + +class Texture; +class TextureAtlas; +struct TextureAtlasTile; + +const uint8_t LOW_GLYPH = 32; +const uint8_t HIGH_GLYPH = 127; + +/** + * Represents a font that has been pre-rendered at a given size to a + * texture atlas so that text can be rendered quickly as sprites. + */ +class SpriteFont : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "SpriteFont"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + /** + * Creates an uninitialized sprite font object. + */ + SpriteFont(); + virtual ~SpriteFont(); + + /** + * Populates this sprite font object with texture and glyph data + * necessary for rendering with it. + * @param texture the texture containing the font glyphs. This texture + * is expected to have been manually created and not + * loaded through ContentManager. + * @param glyphs texture atlas with pre-defined sub-textures corresponding + * to the font's individual characters (glyphs) + * @param size the size that the glyphs were rendered at + */ + void Load(Texture *texture, TextureAtlas *glyphs, uint8_t size); + + /** + * Lost OpenGL graphics context callback. This will free the texture + * and texture atlas passed to Load(). + */ + void OnLostContext(); + + /** + * @return the size that the glyphs were originally rendered at + */ + uint8_t GetSize() const { return m_size; } + + /** + * @return the texture containing the font glyphs + */ + const Texture* GetTexture() const { return m_texture; } + + /** + * @return the number of pixels that one line of text rendered with this + * font takes up + */ + uint8_t GetLetterHeight() const { return m_letterHeight; } + + /** + * @param c the character to get sub-texture dimensions/positioning for + * @return the sub-texture dimensions/position corresponding with + * the specified character + */ + const TextureAtlasTile& GetGlyph(unsigned char c) const; + + /** + * Measures the given string of text and returns the width and height + * that it would take up in pixels if rendered. + * @param width the width in pixels of the rendered text if not NULL + * @param height the height in pixels of the rendered text if not NULL + * @param format the text to measure + */ + void MeasureString(uint16_t *width, uint16_t *height, const char *format, ...) const; + + /** + * Measures the given string of text and returns the width and height + * that it would take up in pixels if rendered. + * @param width the width in pixels of the rendered text if not NULL + * @param height the height in pixels of the rendered text if not NULL + * @param scale a scaling factor for rendering to take into account + * @param format the text to measure + */ + void MeasureString(uint16_t *width, uint16_t *height, float scale, const char *format, ...) const; + +private: + uint8_t m_size; + + Texture *m_texture; + TextureAtlas *m_glyphs; + uint8_t m_letterHeight; +}; + +#endif diff --git a/src/framework/graphics/spriteshader.cpp b/src/framework/graphics/spriteshader.cpp new file mode 100644 index 0000000..f9a61d1 --- /dev/null +++ b/src/framework/graphics/spriteshader.cpp @@ -0,0 +1,22 @@ +#include "../debug.h" + +#include "spriteshader.h" + +SpriteShader::SpriteShader() + : StandardShader() +{ + STACK_TRACE; + SetTextureHasAlphaOnlyUniform("u_textureHasAlphaOnly"); +} + +SpriteShader::~SpriteShader() +{ + STACK_TRACE; +} + +void SpriteShader::SetTextureHasAlphaOnly(BOOL hasAlphaOnly) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_textureHasAlphaOnlyUniform, (int32_t)hasAlphaOnly); +} diff --git a/src/framework/graphics/spriteshader.h b/src/framework/graphics/spriteshader.h new file mode 100644 index 0000000..8773a27 --- /dev/null +++ b/src/framework/graphics/spriteshader.h @@ -0,0 +1,45 @@ +#ifndef __FRAMEWORK_GRAPHICS_SPRITESHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_SPRITESHADER_H_INCLUDED__ + +#include "../common.h" +#include "standardshader.h" +#include + +/** + * Base class for shaders which will be used to render sprites primarily. + */ +class SpriteShader : public StandardShader +{ +public: + virtual ~SpriteShader(); + + /** + * Sets whether the texture that will be used for rendering consists + * of only an alpha channel (no RGB information). This will affect + * the way which color modulation is done using vertex colors. + * @param hasAlphaOnly whether the texture has only an alpha component + */ + void SetTextureHasAlphaOnly(BOOL hasAlphaOnly); + +protected: + /** + * Initializes standard uniform information to defaults. + */ + SpriteShader(); + + /** + * @return the name of the "texture has only an alpha component" uniform + */ + const stl::string& GetTextureHasAlphaOnlyUniform() const { return m_textureHasAlphaOnlyUniform; } + + /** + * Sets the name of the "texture has only an alpha component" uniform. +. * @param name the name of the uniform + */ + void SetTextureHasAlphaOnlyUniform(const stl::string &name) { m_textureHasAlphaOnlyUniform = name; } + +private: + stl::string m_textureHasAlphaOnlyUniform; +}; + +#endif diff --git a/src/framework/graphics/standardshader.cpp b/src/framework/graphics/standardshader.cpp new file mode 100644 index 0000000..299f90f --- /dev/null +++ b/src/framework/graphics/standardshader.cpp @@ -0,0 +1,63 @@ +#include "../debug.h" + +#include "standardshader.h" +#include "../math/matrix4x4.h" + +StandardShader::StandardShader() + : Shader() +{ + STACK_TRACE; + m_inlineVertexShaderSource = NULL; + m_inlineFragmentShaderSource = NULL; + + SetModelViewMatrixUniform("u_modelViewMatrix"); + SetProjectionMatrixUniform("u_projectionMatrix"); +} + +StandardShader::~StandardShader() +{ + STACK_TRACE; +} + +BOOL StandardShader::LoadCompileAndLinkInlineSources(const char *inlineVertexShaderSource, const char *inlineFragmentShaderSource) +{ + STACK_TRACE; + ASSERT(inlineVertexShaderSource != NULL); + ASSERT(inlineFragmentShaderSource != NULL); + + BOOL result = LoadCompileAndLink(inlineVertexShaderSource, inlineFragmentShaderSource); + if (result) + { + // keep the pointers around to the inline sources for easy reloading later + // (of course this means that these pointers need to be kept valid for a long time) + m_inlineVertexShaderSource = inlineVertexShaderSource; + m_inlineFragmentShaderSource = inlineFragmentShaderSource; + } + + return result; +} + +void StandardShader::SetModelViewMatrix(const Matrix4x4 &matrix) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_modelViewMatrixUniform, matrix); +} + +void StandardShader::SetProjectionMatrix(const Matrix4x4 &matrix) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_projectionMatrixUniform, matrix); +} + +void StandardShader::OnNewContext() +{ + STACK_TRACE; + ReloadCompileAndLink(m_inlineVertexShaderSource, m_inlineFragmentShaderSource); +} + +void StandardShader::OnLostContext() +{ + STACK_TRACE; +} diff --git a/src/framework/graphics/standardshader.h b/src/framework/graphics/standardshader.h new file mode 100644 index 0000000..48cd920 --- /dev/null +++ b/src/framework/graphics/standardshader.h @@ -0,0 +1,86 @@ +#ifndef __FRAMEWORK_GRAPHICS_STANDARDSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_STANDARDSHADER_H_INCLUDED__ + +#include "shader.h" +#include + +struct Matrix4x4; + +/** + * Base class for shaders which always provided uniforms for certain + * things. + */ +class StandardShader : public Shader +{ +public: + virtual ~StandardShader(); + + /** + * Sets the modelview matrix uniform. + * @param matrix the matrix to set + */ + void SetModelViewMatrix(const Matrix4x4 &matrix); + + /** + * Sets the projection matrix uniform. + * @param matrix the matrix to set + */ + void SetProjectionMatrix(const Matrix4x4 &matrix); + + /** + * New OpenGL graphics context creation callback. + */ + virtual void OnNewContext(); + + /** + * Lost OpenGL graphics context callback. + */ + virtual void OnLostContext(); + +protected: + /** + * Initializes standard uniform information to defaults. + */ + StandardShader(); + + /** + * Loads, compiles and links shader sources from strings that are + * defined via constants or statically in the application C++ code. + * @param vertexShaderSource vertex shader source + * @param fragmentShaderSource fragment shader source + * @return TRUE if compilation and linking succeeded and the shader + * is now ready for use + */ + BOOL LoadCompileAndLinkInlineSources(const char *inlineVertexShaderSource, const char *inlineFragmentShaderSource); + + /** + * @return the name of the modelview matrix uniform + */ + const stl::string& GetModelViewMatrixUniform() const { return m_modelViewMatrixUniform; } + + /** + * @return the name of the projection matrix uniform + */ + const stl::string& GetProjectionMatrixUniform() const { return m_projectionMatrixUniform; } + + /** + * Sets the name of the modelview matrix uniform. +. * @param name the name of the uniform + */ + void SetModelViewMatrixUniform(const stl::string &name) { m_modelViewMatrixUniform = name; } + + /** + * Sets the name of the projection matrix uniform. + * @param name the name of the uniform + */ + void SetProjectionMatrixUniform(const stl::string &name) { m_projectionMatrixUniform = name; } + +private: + stl::string m_modelViewMatrixUniform; + stl::string m_projectionMatrixUniform; + + const char *m_inlineVertexShaderSource; + const char *m_inlineFragmentShaderSource; +}; + +#endif diff --git a/src/framework/graphics/texture.cpp b/src/framework/graphics/texture.cpp new file mode 100644 index 0000000..45718cc --- /dev/null +++ b/src/framework/graphics/texture.cpp @@ -0,0 +1,241 @@ +#include "../debug.h" +#include "../log.h" + +#include "../common.h" +#include "texture.h" +#include "glincludes.h" +#include "glutils.h" +#include "graphicsdevice.h" +#include "image.h" +#include "textureparameters.h" +#include "../math/mathhelpers.h" + +Texture::Texture() + : Content() +{ + STACK_TRACE; + m_graphicsDevice = NULL; + m_textureName = 0; + m_width = 0; + m_height = 0; + m_format = TEXTURE_FORMAT_NONE; +} + +Texture::~Texture() +{ + STACK_TRACE; + Release(); +} + +BOOL Texture::Create(GraphicsDevice *graphicsDevice, Image *image) +{ + STACK_TRACE; + ASSERT(m_textureName == 0); + if (m_textureName != 0) + return FALSE; + + ASSERT(graphicsDevice != NULL); + ASSERT(IsPowerOf2(image->GetWidth()) && IsPowerOf2(image->GetHeight())); + ASSERT(image->GetBpp() != 8 || image->GetFormat() == IMAGE_FORMAT_ALPHA); + ASSERT(image->GetBpp() != 16); + + const void* pixels = image->GetPixels(); + TEXTURE_FORMAT format = TEXTURE_FORMAT_NONE; + uint32_t glFormat = 0; + uint32_t glType = GL_UNSIGNED_BYTE; + + if (image->GetFormat() == IMAGE_FORMAT_ALPHA) + { + glFormat = GL_ALPHA; + format = TEXTURE_FORMAT_ALPHA; + } + else + { + if (image->GetBpp() == 24) + { + glFormat = GL_RGB; + format = TEXTURE_FORMAT_RGB; + } + else if (image->GetBpp() == 32) + { + glFormat = GL_RGBA; + format = TEXTURE_FORMAT_RGBA; + } + } + ASSERT(glFormat != 0); + if (glFormat == 0) + return FALSE; + + m_graphicsDevice = graphicsDevice; + m_width = image->GetWidth(); + m_height = image->GetHeight(); + m_format = format; + + GL_CALL(glGenTextures(1, &m_textureName)); + + m_graphicsDevice->BindTexture(this, 0); + m_graphicsDevice->GetTextureParameters()->Apply(); + + GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, glFormat, image->GetWidth(), image->GetHeight(), 0, glFormat, glType, pixels)); + + LOG_INFO(LOGCAT_GRAPHICS, "Created texture from image. ID = %d, bpp = %d, size = %d x %d\n", m_textureName, image->GetBpp(), image->GetWidth(), image->GetHeight()); + + return TRUE; +} + +BOOL Texture::Create(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height, TEXTURE_FORMAT textureFormat) +{ + STACK_TRACE; + ASSERT(m_textureName == 0); + if (m_textureName != 0) + return FALSE; + + ASSERT(graphicsDevice != NULL); + if (!graphicsDevice->IsNonPowerOfTwoTextureSupported()) + { + ASSERT(IsPowerOf2(width) && IsPowerOf2(height)); + if (!IsPowerOf2(width) || !IsPowerOf2(height)) + return FALSE; + } + + int bpp = 0; + uint32_t format = 0; + uint32_t type = 0; + GetTextureSpecsFromFormat(textureFormat, &bpp, &format, &type); + ASSERT(format != 0); + if (format == 0) + return FALSE; + ASSERT(type != 0); + if (type == 0) + return FALSE; + + m_graphicsDevice = graphicsDevice; + m_width = width; + m_height = height; + m_format = textureFormat; + + GL_CALL(glGenTextures(1, &m_textureName)); + + m_graphicsDevice->BindTexture(this, 0); + m_graphicsDevice->GetTextureParameters()->Apply(); + + // allocate texture memory, but leave it uninitialized + GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, NULL)); + + if (textureFormat == GL_DEPTH_COMPONENT) + LOG_INFO(LOGCAT_GRAPHICS, "Created uninitialized texture. ID = %d, depth component only, size = %d x %d\n", m_textureName, m_width, m_height); + else + LOG_INFO(LOGCAT_GRAPHICS, "Created uninitialized texture. ID = %d, bpp = %d, size = %d x %d\n", m_textureName, bpp, m_width, m_height); + + return TRUE; +} + +void Texture::Release() +{ + STACK_TRACE; + if (m_textureName != 0) + { + m_graphicsDevice->UnbindTexture(this); + GL_CALL(glDeleteTextures(1, &m_textureName)); + + LOG_INFO(LOGCAT_GRAPHICS, "Deleted Texture ID = %d.\n", m_textureName); + } + + m_textureName = 0; + m_graphicsDevice = NULL; + m_width = 0; + m_height = 0; + m_format = TEXTURE_FORMAT_NONE; +} + +BOOL Texture::Update(Image *image, uint16_t destX, uint16_t destY) +{ + STACK_TRACE; + ASSERT(m_textureName != 0); + if (m_textureName == 0) + return FALSE; + + // TODO: for now ... + ASSERT(m_format != TEXTURE_FORMAT_DEPTH); + if (m_format == TEXTURE_FORMAT_DEPTH) + return FALSE; + + ASSERT(image != NULL); + ASSERT(destX < m_width); + ASSERT(destY < m_height); + ASSERT(image->GetWidth() <= m_width); + ASSERT(image->GetHeight() <= m_height); + ASSERT(destX + image->GetWidth() <= m_width); + ASSERT(destY + image->GetHeight() <= m_height); + + const void* pixels = image->GetPixels(); + uint32_t glFormat = 0; + uint32_t glType = 0; + + if (image->GetFormat() == IMAGE_FORMAT_ALPHA) + { + glFormat = GL_ALPHA; + glType = GL_UNSIGNED_BYTE; + } + else + { + glType = GL_UNSIGNED_BYTE; + if (image->GetBpp() == 24) + glFormat = GL_RGB; + else if (image->GetBpp() == 32) + glFormat = GL_RGBA; + } + + ASSERT(glFormat != 0); + if (glFormat == 0) + return FALSE; + + m_graphicsDevice->BindTexture(this, 0); + GL_CALL(glTexSubImage2D(GL_TEXTURE_2D, 0, destX, destY, image->GetWidth(), image->GetHeight(), glFormat, glType, pixels)); + + return TRUE; +} + +void Texture::OnLostContext() +{ + STACK_TRACE; + m_textureName = 0; +} + +void Texture::GetTextureSpecsFromFormat(TEXTURE_FORMAT textureFormat, int *bpp, uint32_t *format, uint32_t *type) +{ + STACK_TRACE; + switch (textureFormat) + { + case TEXTURE_FORMAT_ALPHA: + if (bpp) *bpp = 8; + if (format) *format = GL_ALPHA; + if (type) *type = GL_UNSIGNED_BYTE; + break; + case TEXTURE_FORMAT_RGB: + if (bpp) *bpp = 24; + if (format) *format = GL_RGB; + if (type) *type = GL_UNSIGNED_BYTE; + break; + case TEXTURE_FORMAT_RGBA: + if (bpp) *bpp = 32; + if (format) *format = GL_RGBA; + if (type) *type = GL_UNSIGNED_BYTE; + break; + case TEXTURE_FORMAT_DEPTH: + if (bpp) *bpp = 0; // doesn't really matter for this one... ? + if (format) *format = GL_DEPTH_COMPONENT; + + // TODO: check that these are correct ... +#ifdef MOBILE + if (type) *type = GL_UNSIGNED_SHORT; +#else + if (type) *type = GL_FLOAT; +#endif + break; + default: + if (bpp) *bpp = 0; + if (format) *format = 0; + if (type) *type = 0; + } +} diff --git a/src/framework/graphics/texture.h b/src/framework/graphics/texture.h new file mode 100644 index 0000000..f46968e --- /dev/null +++ b/src/framework/graphics/texture.h @@ -0,0 +1,102 @@ +#ifndef __FRAMEWORK_GRAPHICS_TEXTURE_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_TEXTURE_H_INCLUDED__ + +#include "../common.h" +#include "../content/content.h" +#include "textureformats.h" + +class GraphicsDevice; +class Image; + +/** + * Represents a texture that can be bound and rendered with. + */ +class Texture : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "Texture"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + Texture(); + virtual ~Texture(); + + /** + * Creates a new texture from the specified image. + * @param graphicsDevice the graphics device this texture is associated with + * @param image the image to create the texture from + * @return TRUE if the texture was created successfully + */ + BOOL Create(GraphicsDevice *graphicsDevice, Image *image); + + /** + * Creates a new texture with uninitialized image data. Image data should + * be uploaded to the texture before using it via Update(). + * @param graphicsDevice the graphics device this texture is associated with + * @param width the width of the texture in pixels + * @param height the height of the texture in pixels + * @param textureFormat the format of the pixel data this texture contains + */ + BOOL Create(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height, TEXTURE_FORMAT textureFormat); + + /** + * Frees the texture resources. + */ + void Release(); + + /** + * Updates all of or just part of an this texture with new image data. + * @param image the image to upload to the texture. This image should + * have dimensions equal to or less then this texture. + * @param destX the X coordinate on the texture to place the new image at + * @param destY the Y coordinate on the texture to place the new image at + * @return TRUE if the texture was updated successfully + */ + BOOL Update(Image *image, uint16_t destX = 0, uint16_t destY = 0); + + /** + * @return the texture name or ID assigned to this texture by OpenGL + */ + uint32_t GetTextureName() const { return m_textureName; } + + /** + * @return the width of this texture in pixels + */ + uint16_t GetWidth() const { return m_width; } + + /** + * @return the height of this texture in pixels + */ + uint16_t GetHeight() const { return m_height; } + + /** + * @return the pixel format of this texture + */ + TEXTURE_FORMAT GetFormat() const { return m_format; } + + /** + * @return TRUE if the texture has invalidated and needs to be recreated + */ + BOOL IsInvalidated() const { return m_textureName == 0; } + + /** + * Callback which handles freeing the texture resources when the OpenGL + * context is lost. This prepares the texture object to be reloaded + * via one of the Create() methods when the OpenGL context is regained. + */ + void OnLostContext(); + +private: + void GetTextureSpecsFromFormat(TEXTURE_FORMAT textureFormat, int *bpp, uint32_t *format, uint32_t *type); + + GraphicsDevice *m_graphicsDevice; + uint32_t m_textureName; + uint16_t m_width; + uint16_t m_height; + TEXTURE_FORMAT m_format; +}; + +#endif diff --git a/src/framework/graphics/textureatlas.cpp b/src/framework/graphics/textureatlas.cpp new file mode 100644 index 0000000..01f58ea --- /dev/null +++ b/src/framework/graphics/textureatlas.cpp @@ -0,0 +1,47 @@ +#include "../debug.h" + +#include "textureatlas.h" + +#include "texture.h" + +TextureAtlas::TextureAtlas(uint16_t textureWidth, uint16_t textureHeight, float texCoordEdgeOffset) +{ + STACK_TRACE; + ASSERT(textureWidth > 0); + ASSERT(textureHeight > 0); + + m_source = NULL; + m_textureWidth = textureWidth; + m_textureHeight = textureHeight; + m_texCoordEdgeOffset = texCoordEdgeOffset; +} + +TextureAtlas::TextureAtlas(Texture *source, float texCoordEdgeOffset) +{ + STACK_TRACE; + ASSERT(source != NULL); + + m_source = source; + m_textureWidth = m_source->GetWidth(); + m_textureHeight = m_source->GetHeight(); + m_texCoordEdgeOffset = texCoordEdgeOffset; +} + +TextureAtlas::~TextureAtlas() +{ + STACK_TRACE; +} + +void TextureAtlas::SetTexture(Texture *source) +{ + STACK_TRACE; + if (source == NULL) + m_source = NULL; + else + { + // must match the existing dimensions set for this atlas + ASSERT(source->GetWidth() == m_textureWidth); + ASSERT(source->GetHeight() == m_textureHeight); + m_source = source; + } +} diff --git a/src/framework/graphics/textureatlas.h b/src/framework/graphics/textureatlas.h new file mode 100644 index 0000000..b3a9502 --- /dev/null +++ b/src/framework/graphics/textureatlas.h @@ -0,0 +1,113 @@ +#ifndef __FRAMEWORK_GRAPHICS_TEXTUREATLAS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_TEXTUREATLAS_H_INCLUDED__ + +#include "../common.h" + +#include "../math/rect.h" +#include "../math/rectf.h" + +#include + +class Texture; + +const float TEXCOORD_EDGE_BLEED_OFFSET = 0.02f; + +/** + * Contains information defining a sub-texture or image in a + * texture atlas. + */ +struct TextureAtlasTile +{ + Rect dimensions; + RectF texCoords; +}; + +/** + * Base class for a sub-image texture manager allowing the use of a + * single texture object to contain many individual smaller textures + * to render with. + */ +class TextureAtlas +{ +public: + virtual ~TextureAtlas(); + + /** + * @return the underlying texture object, or NULL if not set + */ + const Texture* GetTexture() const { return m_source; } + + /** + * @return the underlying texture object, or NULL if not set + */ + Texture* GetTexture() { return m_source; } + + /** + * @return the width in pixels of the underlying texture object + */ + uint16_t GetWidth() const { return m_textureWidth; } + + /** + * @return the height in pixels of the underlying texture object + */ + uint16_t GetHeight() const { return m_textureHeight; } + + /** + * @return the number of sub-textures or tiles currently contained in this atlas + */ + uint32_t GetNumTextures() const { return m_tiles.size(); } + + /** + * Gets position and dimension information about a specified + * sub-texture or tile. + * @param index the index of the sub-texture or tile to retrieve + * @return the sub-texture/tile's information + */ + const TextureAtlasTile& GetTile(uint32_t index) const { return m_tiles[index]; } + + /** + * Sets the underlying texture object for this atlas. + * @param source the texture to use for this atlas + */ + void SetTexture(Texture *source); + +protected: + /** + * Sets the base texture atlas object. + * @param textureWidth the width in pixels of the texture that will + * be used for this atlas + * @param textureHeight the height in pixels of the texture that + * will be used for this atlas + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + TextureAtlas(uint16_t textureWidth, uint16_t textureHeight, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + /** + * Sets the base texture object. + * @param source the underlying texture to use for this atlas + * @param texCoordEdgeOffset an offset value that will be used to + * help alleviate "texture bleeding" + * issues while rendering + */ + TextureAtlas(Texture *source, float texCoordEdgeOffset = TEXCOORD_EDGE_BLEED_OFFSET); + + /** + * @return an offset value that can be used to help alleviate + * "texture bleeding" when used in conjunction with sub-texture + * UV coordinates + */ + float GetTexCoordEdgeOffset() const { return m_texCoordEdgeOffset; } + + stl::vector m_tiles; + +private: + uint16_t m_textureWidth; + uint16_t m_textureHeight; + Texture *m_source; + float m_texCoordEdgeOffset; +}; + +#endif + diff --git a/src/framework/graphics/textureformats.h b/src/framework/graphics/textureformats.h new file mode 100644 index 0000000..9d935aa --- /dev/null +++ b/src/framework/graphics/textureformats.h @@ -0,0 +1,16 @@ +#ifndef __FRAMEWORK_GRAPHICS_TEXTUREFORMATS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_TEXTUREFORMATS_H_INCLUDED__ + +/** + * Constant values to refer to different kinds of texture data formats. + */ +enum TEXTURE_FORMAT +{ + TEXTURE_FORMAT_NONE = 0, + TEXTURE_FORMAT_RGB = 1, + TEXTURE_FORMAT_RGBA = 2, + TEXTURE_FORMAT_ALPHA = 3, + TEXTURE_FORMAT_DEPTH = 4 +}; + +#endif diff --git a/src/framework/graphics/textureparameters.cpp b/src/framework/graphics/textureparameters.cpp new file mode 100644 index 0000000..a8e01d6 --- /dev/null +++ b/src/framework/graphics/textureparameters.cpp @@ -0,0 +1,78 @@ +#include "../debug.h" + +#include "textureparameters.h" + +#include "glincludes.h" +#include "glutils.h" + +TextureParameters::TextureParameters() +{ + STACK_TRACE; + Initialize(); +} + +TextureParameters::TextureParameters(MINIFICATION_FILTER minFilter, MAGNIFICATION_FILTER magFilter) +{ + STACK_TRACE; + Initialize(); + + m_minFilter = minFilter; + m_magFilter = magFilter; +} + +TextureParameters::~TextureParameters() +{ + STACK_TRACE; +} + +void TextureParameters::Initialize() +{ + STACK_TRACE; + m_minFilter = MIN_NEAREST; + m_magFilter = MAG_LINEAR; + m_wrapS = REPEAT; + m_wrapT = REPEAT; +} + +void TextureParameters::Apply() const +{ + STACK_TRACE; + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, FindMinificationFilterValue(m_minFilter))); + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, FindMagnificationFilterValue(m_magFilter))); + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, FindWrapModeValue(m_wrapS))); + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, FindWrapModeValue(m_wrapT))); +} + +int TextureParameters::FindMinificationFilterValue(MINIFICATION_FILTER filter) const +{ + STACK_TRACE; + switch (filter) + { + case MIN_NEAREST: return GL_NEAREST; + case MIN_LINEAR: return GL_LINEAR; + case MIN_NEAREST_MIPMAP_NEAREST: return GL_NEAREST_MIPMAP_NEAREST; + case MIN_LINEAR_MIPMAP_NEAREST: return GL_LINEAR_MIPMAP_NEAREST; + case MIN_NEAREST_MIPMAP_LINEAR: return GL_NEAREST_MIPMAP_LINEAR; + default: return GL_LINEAR_MIPMAP_LINEAR; + } +} + +int TextureParameters::FindMagnificationFilterValue(MAGNIFICATION_FILTER filter) const +{ + STACK_TRACE; + switch (filter) + { + case MAG_NEAREST: return GL_NEAREST; + default: return GL_LINEAR; + } +} + +int TextureParameters::FindWrapModeValue(WRAP_MODE mode) const +{ + STACK_TRACE; + switch (mode) + { + case CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE; + default: return GL_REPEAT; + } +} diff --git a/src/framework/graphics/textureparameters.h b/src/framework/graphics/textureparameters.h new file mode 100644 index 0000000..ad1bcf7 --- /dev/null +++ b/src/framework/graphics/textureparameters.h @@ -0,0 +1,112 @@ +#ifndef __FRAMEWORK_GRAPHICS_TEXTUREPARAMETERS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_TEXTUREPARAMETERS_H_INCLUDED__ + +#include "../common.h" + +enum MINIFICATION_FILTER +{ + MIN_NEAREST, + MIN_LINEAR, + MIN_NEAREST_MIPMAP_NEAREST, + MIN_LINEAR_MIPMAP_NEAREST, + MIN_NEAREST_MIPMAP_LINEAR, + MIN_LINEAR_MIPMAP_LINEAR +}; + +enum MAGNIFICATION_FILTER +{ + MAG_NEAREST, + MAG_LINEAR +}; + +enum WRAP_MODE +{ + CLAMP_TO_EDGE, + REPEAT +}; + +/** + * Wraps texture parameter for OpenGL. Instances of this class can be initialized + * and then used later on during execution to quickly apply a set of texture + * parameters. + */ +class TextureParameters +{ +public: + /** + * Creates a new texture parameter object with default settings matching OpenGL's + * initial settings. + */ + TextureParameters(); + + /** + * Creates a new texture parameter object with default settings matching OpenGL's + * initial settings except for those specified. + * @param minFilter texture minifying function + * @param magFilter texture magnification function + */ + TextureParameters(MINIFICATION_FILTER minFilter, MAGNIFICATION_FILTER magFilter); + + virtual ~TextureParameters(); + + /** + * Applies texture parameter to the current OpenGL context. + */ + void Apply() const; + + /** + * @return the texture minifying function + */ + MINIFICATION_FILTER GetMinFilter() const { return m_minFilter; } + + /** + * @return the texture magnification function + */ + MAGNIFICATION_FILTER GetMagFilter() const { return m_magFilter; } + + /** + * @return texture wrapping mode for S (or U) texture coordinates + */ + WRAP_MODE GetWrapS() const { return m_wrapS; } + + /** + * @return texture wrapping mode for T (or V) texture coordinates + */ + WRAP_MODE GetWrapT() const { return m_wrapT; } + + /** + * Sets the texture minifying function. + */ + void SetMinFilter(MINIFICATION_FILTER filter) { m_minFilter = filter; } + + /** + * Sets the texture magnification function. + */ + void SetMagFilter(MAGNIFICATION_FILTER filter) { m_magFilter = filter; } + + /** + * Sets the texture wrapping mode for S (or U) texture coordinates. + */ + void SetWrapS(WRAP_MODE mode) { m_wrapS = mode; } + + /** + * Sets the texture wrapping mode for T (or V) texture coordinates. + */ + void SetWrapT(WRAP_MODE mode) { m_wrapT = mode; } + +private: + void Initialize(); + int FindMinificationFilterValue(MINIFICATION_FILTER filter) const; + int FindMagnificationFilterValue(MAGNIFICATION_FILTER filter) const; + int FindWrapModeValue(WRAP_MODE mode) const; + + MINIFICATION_FILTER m_minFilter; + MAGNIFICATION_FILTER m_magFilter; + WRAP_MODE m_wrapS; + WRAP_MODE m_wrapT; +}; + +#define TEXPARAM_DEFAULT TextureParameters() +#define TEXPARAM_PIXELATED TextureParameters(MIN_NEAREST, MAG_NEAREST) + +#endif diff --git a/src/framework/graphics/vertexattribs.h b/src/framework/graphics/vertexattribs.h new file mode 100644 index 0000000..118c4d7 --- /dev/null +++ b/src/framework/graphics/vertexattribs.h @@ -0,0 +1,62 @@ +#ifndef __FRAMEWORK_GRAPHICS_VERTEXATTRIBS_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_VERTEXATTRIBS_H_INCLUDED__ + +#include "../common.h" + +/** + * Constant values to refer to different standard types of vertex attributes. + */ +enum VERTEX_ATTRIBS +{ + VERTEX_POS_2D = 1, + VERTEX_POS_3D = 2, + VERTEX_NORMAL = 4, + VERTEX_COLOR = 8, + VERTEX_TEXCOORD = 16, + VERTEX_GENERIC = 32 +}; + +/** + * Common attribute sizes. + */ +enum VERTEX_ATTRIB_SIZES +{ + ATTRIB_SIZE_1F = 1, + ATTRIB_SIZE_2F = 2, + ATTRIB_SIZE_VEC2 = 2, + ATTRIB_SIZE_3F = 3, + ATTRIB_SIZE_VEC3 = 3, + ATTRIB_SIZE_4F = 4, + ATTRIB_SIZE_VEC4 = 4, + ATTRIB_SIZE_MAT3X3 = 9, + ATTRIB_SIZE_MAT4x4 = 16 +}; + +/** + * Holds information about what type and size of data a single attribute + * in a vertex buffer is for. + */ +struct VertexBufferAttribute +{ + /** + * The standard type of the attribute data. This will be VERTEX_GENERIC + * if not a standard type (that is, when this attribute is not for the + * "primary" 2D/3D vertex position, texture coordinates, normals, etc). + */ + VERTEX_ATTRIBS standardType; + + /** + * The number of floating point value components that make up the + * attribute. e.g. 3 for a Vector3, 4 for a Color, etc. + */ + uint32_t size; + + /** + * The offset from the start of a vertex to where this attribute's data + * begins. Specified as the number of floating point components + * (Multiply by sizeof(float) to get the offset as the number of bytes). + */ + uint32_t offset; +}; + +#endif diff --git a/src/framework/graphics/vertexbuffer.cpp b/src/framework/graphics/vertexbuffer.cpp new file mode 100644 index 0000000..68274f3 --- /dev/null +++ b/src/framework/graphics/vertexbuffer.cpp @@ -0,0 +1,255 @@ +#include "../debug.h" + +#include "glincludes.h" +#include "glutils.h" +#include "vertexbuffer.h" + +const unsigned int FLOATS_PER_GPU_ATTRIB_SLOT = 4; +const unsigned int MAX_GPU_ATTRIB_SLOTS = 8; + +VertexBuffer::VertexBuffer(BUFFEROBJECT_USAGE usage) + : BufferObject(BUFFEROBJECT_TYPE_VERTEX, usage) +{ + STACK_TRACE; + m_numVertices = 0; + m_currentVertex = 0; + m_standardTypeAttribs = 0; + m_elementWidth = 0; + m_colorOffset = 0; + m_position2Offset = 0; + m_position3Offset = 0; + m_normalOffset = 0; + m_texCoordOffset = 0; + m_numGPUAttributeSlotsUsed = 0; +} + +VertexBuffer::~VertexBuffer() +{ + STACK_TRACE; +} + +BOOL VertexBuffer::AddAttribute(uint32_t size, VERTEX_ATTRIBS standardType) +{ + STACK_TRACE; + ASSERT(standardType == VERTEX_GENERIC || HasStandardAttrib(standardType) == FALSE); + ASSERT(size <= 16); + + if (standardType != VERTEX_GENERIC && HasStandardAttrib(standardType)) + return FALSE; + if (size > 16) + return FALSE; + + // using integer division that rounds up (so given size = 13, result is 4, not 3) + uint32_t numGPUAttributeSlotsUsed = (size + (FLOATS_PER_GPU_ATTRIB_SLOT - 1)) / FLOATS_PER_GPU_ATTRIB_SLOT; + ASSERT(m_numGPUAttributeSlotsUsed + numGPUAttributeSlotsUsed <= MAX_GPU_ATTRIB_SLOTS); + if (m_numGPUAttributeSlotsUsed + numGPUAttributeSlotsUsed > MAX_GPU_ATTRIB_SLOTS) + return FALSE; + + VertexBufferAttribute newAttrib; + newAttrib.standardType = standardType; + newAttrib.size = size; + newAttrib.offset = m_elementWidth; + + switch (standardType) + { + case VERTEX_POS_2D: + ASSERT(size == 2); + if (size != 2) + return FALSE; + m_position2Offset = newAttrib.offset; + break; + case VERTEX_POS_3D: + ASSERT(size == 3); + if (size != 3) + return FALSE; + m_position3Offset = newAttrib.offset; + break; + case VERTEX_NORMAL: + ASSERT(size == 3); + if (size != 3) + return FALSE; + m_normalOffset = newAttrib.offset; + break; + case VERTEX_COLOR: + ASSERT(size == 4); + if (size != 4) + return FALSE; + m_colorOffset = newAttrib.offset; + break; + case VERTEX_TEXCOORD: + ASSERT(size == 2); + if (size != 2) + return FALSE; + m_texCoordOffset = newAttrib.offset; + break; + case VERTEX_GENERIC: + break; + } + + m_attribs.push_back(newAttrib); + + m_elementWidth += size; + m_numGPUAttributeSlotsUsed += numGPUAttributeSlotsUsed; + SetBit(standardType, m_standardTypeAttribs); + + return TRUE; +} + +BOOL VertexBuffer::AddAttribute(VERTEX_ATTRIBS standardType) +{ + STACK_TRACE; + ASSERT(standardType != VERTEX_GENERIC); + if (standardType == VERTEX_GENERIC) + return FALSE; + + ASSERT(HasStandardAttrib(standardType) == FALSE); + if (HasStandardAttrib(standardType)) + return FALSE; + + BOOL result = FALSE; + + switch (standardType) + { + case VERTEX_POS_2D: + result = AddAttribute(ATTRIB_SIZE_VEC2, VERTEX_POS_2D); + break; + case VERTEX_POS_3D: + result = AddAttribute(ATTRIB_SIZE_VEC3, VERTEX_POS_3D); + break; + case VERTEX_NORMAL: + result = AddAttribute(ATTRIB_SIZE_VEC3, VERTEX_NORMAL); + break; + case VERTEX_COLOR: + result = AddAttribute(ATTRIB_SIZE_VEC4, VERTEX_COLOR); + break; + case VERTEX_TEXCOORD: + result = AddAttribute(ATTRIB_SIZE_VEC2, VERTEX_TEXCOORD); + break; + case VERTEX_GENERIC: + break; + } + + return result; +} + +BOOL VertexBuffer::CopyAttributesFrom(const VertexBuffer *source) +{ + STACK_TRACE; + ASSERT(source != NULL); + if (source == NULL) + return FALSE; + + ASSERT(source->GetNumAttributes() != 0); + ASSERT(m_buffer.size() == 0); + + if (source->GetNumAttributes() == 0) + return FALSE; + if (m_buffer.size() > 0) + return FALSE; + + m_attribs.clear(); + for (uint32_t i = 0; i < source->GetNumAttributes(); ++i) + { + const VertexBufferAttribute *sourceAttrib = source->GetAttributeInfo(i); + AddAttribute(sourceAttrib->size, sourceAttrib->standardType); + } + + return TRUE; +} + +int32_t VertexBuffer::GetIndexOfStandardAttrib(VERTEX_ATTRIBS standardAttrib) const +{ + STACK_TRACE; + ASSERT(standardAttrib != VERTEX_GENERIC); + if (standardAttrib == VERTEX_GENERIC) + return -1; + + for (uint32_t i = 0; i < m_attribs.size(); ++i) + { + if (m_attribs[i].standardType == standardAttrib) + return (int32_t)i; + } + + return -1; +} + +BOOL VertexBuffer::Create(uint32_t numVertices) +{ + STACK_TRACE; + ASSERT(m_attribs.size() > 0); + ASSERT(m_buffer.size() == 0); + ASSERT(m_elementWidth > 0); + + if (m_attribs.size() == 0) + return FALSE; + if (m_buffer.size() > 0) + return FALSE; + if (m_elementWidth == 0) + return FALSE; + + Resize(numVertices); + + return TRUE; +} + +BOOL VertexBuffer::CreateCopyOf(const VertexBuffer *source) +{ + STACK_TRACE; + ASSERT(source != NULL); + if (source == NULL) + return FALSE; + + ASSERT(source->GetNumElements() != 0); + ASSERT(m_buffer.size() == 0); + + if (source->GetNumElements() == 0) + return FALSE; + if (m_buffer.size() > 0) + return FALSE; + + BOOL attribCopyResult = CopyAttributesFrom(source); + if (!attribCopyResult) + return FALSE; + + Resize(source->GetNumElements()); + + memcpy(&m_buffer[0], source->GetBuffer(), GetNumElements() * GetElementWidthInBytes()); + + return TRUE; +} + + +void VertexBuffer::Resize(uint32_t numVertices) +{ + STACK_TRACE; + m_buffer.resize(numVertices * m_elementWidth, 0.0f); + m_numVertices = numVertices; + + if (!IsClientSideBuffer()) + SizeBufferObject(); + + if (m_currentVertex >= m_numVertices) + --m_currentVertex; +} + +void VertexBuffer::Extend(uint32_t amount) +{ + STACK_TRACE; + uint32_t newSize = GetNumElements() + amount; + Resize(newSize); +} + +void VertexBuffer::Copy(const VertexBuffer *source, uint32_t destIndex) +{ + STACK_TRACE; + ASSERT(source != NULL); + ASSERT(source->GetNumElements() > 0); + ASSERT(source->GetStandardAttribs() == m_standardTypeAttribs); + ASSERT(destIndex >= 0); + ASSERT(destIndex + source->GetNumElements() <= GetNumElements()); + + uint32_t destOffset = GetVertexPosition(destIndex); + memcpy(&m_buffer[destOffset], source->GetBuffer(), GetNumElements() * GetElementWidthInBytes()); + + SetDirty(); +} diff --git a/src/framework/graphics/vertexbuffer.h b/src/framework/graphics/vertexbuffer.h new file mode 100644 index 0000000..ad70943 --- /dev/null +++ b/src/framework/graphics/vertexbuffer.h @@ -0,0 +1,973 @@ +#ifndef __FRAMEWORK_GRAPHICS_VERTEXBUFFER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_VERTEXBUFFER_H_INCLUDED__ + +#include +#include "../common.h" + +#include "bufferobject.h" +#include "color.h" +#include "../math/matrix3x3.h" +#include "../math/matrix4x4.h" +#include "../math/vector2.h" +#include "../math/vector3.h" +#include + +#include + +#include "vertexattribs.h" + +/** + * Wraps management of an array of vertices stored either completely + * in main memory (client-side) or in video memory. + */ +class VertexBuffer : public BufferObject +{ +public: + /** + * Creates an uninitialized vertex buffer object. + * @param usage the expected usage pattern of this vertex buffer + */ + VertexBuffer(BUFFEROBJECT_USAGE usage); + + /** + * Creates a vertex buffer. + * @param source the source buffer to copy during creation of this buffer + */ + VertexBuffer(const VertexBuffer *source); + + virtual ~VertexBuffer(); + + /** + * Adds an attribute to the vertex buffer. + * @param size the size of the attribute's data (specified in number of floats) + * @param standardType the standard type mapping for ease of use (allowing + * use of special get/set methods for type safety) + * @return TRUE if successful, FALSE if not + */ + BOOL AddAttribute(uint32_t size, VERTEX_ATTRIBS standardType = VERTEX_GENERIC); + + /** + * Adds an attribute to the vertex buffer. + * @param size the size of the attribute's data + * @param standardType the standard type mapping for ease of use (allowing + * use of special get/set methods for type safety) + * @return TRUE if successful, FALSE if not + */ + BOOL AddAttribute(VERTEX_ATTRIB_SIZES size, VERTEX_ATTRIBS standardType = VERTEX_GENERIC); + + /** + * Adds an attribute which will be used for one of the standard types of + * data (e.g. 2D/3D vertex position, color, texture coordinates, etc). The + * other attribute information, like size, will be automatically set. + * @param standardType the standard type of the attribute. Cannot be + * VERTEX_GENERIC. + * @return TRUE if successful, FALSE if not + */ + BOOL AddAttribute(VERTEX_ATTRIBS standardType); + + /** + * Sets this vertex buffer's attributes to match those from a source + * vertex buffer. Any existing attribute information that has been set + * in this vertex buffer will be cleared. + * @param source the source buffer to copy attribute information from + * @return TRUE if successful, FALSE if not + */ + BOOL CopyAttributesFrom(const VertexBuffer *source); + + /** + * @return the number of attributes in this vertex buffer + */ + uint32_t GetNumAttributes() const { return m_attribs.size(); } + + /** + * Returns information about the specified attribute. + * @param index the index of the attribute to get information about + * @return the attribute's information + */ + const VertexBufferAttribute* GetAttributeInfo(uint32_t index) const { return &m_attribs[index]; } + + /** + * @return the standard attributes included in this buffer's data. Note + * that this is not necessarily all of the attributes contained in + * this buffer. + */ + uint32_t GetStandardAttribs() const { return m_standardTypeAttribs; } + + /** + * Checks whether this buffer's vertex data includes the specified standard + * attribute. + * @param standardAttrib the standard attribute to test + * @return TRUE if the vertex data in this buffer contains this standard + * attribute + */ + BOOL HasStandardAttrib(VERTEX_ATTRIBS standardAttrib) const { return (m_standardTypeAttribs & standardAttrib) > 0; } + + /** + * Returns the index of the specified standard attribute. + * @param standardAttrib the standard attribute to get the index of + * @return the index of the attribute, or -1 if it is not present + */ + int32_t GetIndexOfStandardAttrib(VERTEX_ATTRIBS standardAttrib) const; + + /** + * Allocates the client-side memory buffer for this vertex buffer. All + * attributes must have been added via AddAttribute() before this call. No + * more can be added after this call. + * @param numVertices the initial number of vertices this buffer should hold + * @return TRUE if successful, FALSE if not + */ + BOOL Create(uint32_t numVertices); + + /** + * Sets up attributes and data to match a source vertex buffer, making an + * exact copy. Any existing attribute definitions made via AddAttribute() + * before this call will be ignored. No more attributes can be added after + * this call. + * @param source the source buffer to copy + * @return TRUE if successful, FALSE if not + */ + BOOL CreateCopyOf(const VertexBuffer *source); + + /** + * @return the offset from the start of a single vertex's data that the + * color attribute starts at (in floats) + */ + uint32_t GetColorOffset() const { return m_colorOffset; } + + /** + * @return the offset from the start of a single vertex's data that the + * 3D position attribute starts at (in floats) + */ + uint32_t GetPosition3Offset() const { return m_position3Offset; } + + /** + * @return the offset from the start of a single vertex's data that the + * 2D position attribute starts at (in floats) + */ + uint32_t GetPosition2Offset() const { return m_position2Offset; } + + /** + * @return the offset from the start of a single vertex's data that the + * normal attribute starts at (in floats) + */ + uint32_t GetNormalOffset() const { return m_normalOffset; } + + /** + * @return the offset from the start of a single vertex's data that the + * texture coordinate attribute starts at (in floats) + */ + uint32_t GetTexCoordOffset() const { return m_texCoordOffset; } + + /** + * @return the offset from the start of a single vertex's data that the + * color attribute starts at (in bytes) + */ + uint32_t GetColorOffsetBytes() const { return m_colorOffset * sizeof(float); } + + /** + * @return the offset from the start of a single vertex's data that the + * 3D position attribute starts at (in bytes) + */ + uint32_t GetPosition3OffsetBytes() const { return m_position3Offset * sizeof(float); } + + /** + * @return the offset from the start of a single vertex's data that the + * 2D position attribute starts at (in bytes) + */ + uint32_t GetPosition2OffsetBytes() const { return m_position2Offset * sizeof(float); } + + /** + * @return the offset from the start of a single vertex's data that the + * normal attribute starts at (in bytes) + */ + uint32_t GetNormalOffsetBytes() const { return m_normalOffset * sizeof(float); } + + /** + * @return the offset from the start of a single vertex's data that the + * texture coordinate attribute starts at (in bytes) + */ + uint32_t GetTexCoordOffsetBytes() const { return m_texCoordOffset * sizeof(float); } + + /** + * @param index the vertex to get the color data for + * @return the vertex's color data + */ + Color GetColor(uint32_t index) const; + + /** + * @param index the vertex to get the position data for + * @return the vertex's 3D position data + */ + Vector3 GetPosition3(uint32_t index) const; + + /** + * @param index the vertex to get the position data for + * @return the vertex's 2D position data + */ + Vector2 GetPosition2(uint32_t index) const; + + /** + * @param index the vertex to get the normal data for + * @return the vertex's normal data + */ + Vector3 GetNormal(uint32_t index) const; + + /** + * @param index the vertex to get the texture coordinate data for + * @return the vertex's texture coordinate data + */ + Vector2 GetTexCoord(uint32_t index) const; + + void Get1f(uint32_t attrib, uint32_t index, float &x) const; + float Get1f(uint32_t attrib, uint32_t index) const; + void Get2f(uint32_t attrib, uint32_t index, float &x, float &y) const; + void Get2f(uint32_t attrib, uint32_t index, Vector2 &v) const; + Vector2 Get2f(uint32_t attrib, uint32_t index) const; + void Get3f(uint32_t attrib, uint32_t index, float &x, float &y, float &z) const; + void Get3f(uint32_t attrib, uint32_t index, Vector3 &v) const; + Vector3 Get3f(uint32_t attrib, uint32_t index) const; + void Get4f(uint32_t attrib, uint32_t index, float &x, float &y, float &z, float &w) const; + void Get4f(uint32_t attrib, uint32_t index, Color &c) const; + Color Get4f(uint32_t attrib, uint32_t index) const; + void Get9f(uint32_t attrib, uint32_t index, Matrix3x3 &m) const; + Matrix3x3 Get9f(uint32_t attrib, uint32_t index) const; + void Get16f(uint32_t attrib, uint32_t index, Matrix4x4 &m) const; + Matrix4x4 Get16f(uint32_t attrib, uint32_t index) const; + + /** + * @return the current vertex's color data + */ + Color GetCurrentColor() const { return GetColor(GetCurrentPosition()); } + + /** + * @return the current vertex's 3D position data + */ + Vector3 GetCurrentPosition3() const { return GetPosition3(GetCurrentPosition()); } + + /** + * @return the current vertex's 2D position data + */ + Vector2 GetCurrentPosition2() const { return GetPosition2(GetCurrentPosition()); } + + /** + * @return the current vertex's normal data + */ + Vector3 GetCurrentNormal() const { return GetNormal(GetCurrentPosition()); } + + /** + * @return the current vertex's texture coordinate data + */ + Vector2 GetCurrentTexCoord() const { return GetTexCoord(GetCurrentPosition()); } + + void GetCurrent1f(uint32_t attrib, float &x) const { Get1f(attrib, GetCurrentPosition(), x); } + float GetCurrent1f(uint32_t attrib) const { return Get1f(attrib, GetCurrentPosition()); } + void GetCurrent2f(uint32_t attrib, float &x, float &y) const { Get2f(attrib, GetCurrentPosition(), x, y); } + void GetCurrent2f(uint32_t attrib, Vector2 &v) const { Get2f(attrib, GetCurrentPosition(), v); } + Vector2 GetCurrent2f(uint32_t attrib) const { return Get2f(attrib, GetCurrentPosition()); } + void GetCurrent3f(uint32_t attrib, float &x, float &y, float &z) const { Get3f(attrib, GetCurrentPosition(), x, y, z); } + void GetCurrent3f(uint32_t attrib, Vector3 &v) const { Get3f(attrib, GetCurrentPosition(), v); } + Vector3 GetCurrent3f(uint32_t attrib) const { return Get3f(attrib, GetCurrentPosition()); } + void GetCurrent4f(uint32_t attrib, float &x, float &y, float &z, float &w) const { Get4f(attrib, GetCurrentPosition(), x, y, z, w); } + void GetCurrent4f(uint32_t attrib, Color &c) const { Get4f(attrib, GetCurrentPosition(), c); } + Color GetCurrent4f(uint32_t attrib) const { return Get4f(attrib, GetCurrentPosition()); } + void GetCurrent9f(uint32_t attrib, Matrix3x3 &m) const { Get9f(attrib, GetCurrentPosition(), m); } + Matrix3x3 GetCurrent9f(uint32_t attrib) const { return Get9f(attrib, GetCurrentPosition()); } + void GetCurrent16f(uint32_t attrib, Matrix4x4 &m) const { Get16f(attrib, GetCurrentPosition(), m); } + Matrix4x4 GetCurrent16f(uint32_t attrib) const { return Get16f(attrib, GetCurrentPosition()); } + + /** + * Sets a vertex's color attribute. + * @param index the vertex to set + * @param color the new color attribute to set + */ + void SetColor(uint32_t index, const Color &color); + + /** + * Sets a vertex's color attribute. + * @param index the vertex to set + * @param r red component of the color attribute to set + * @param g green component of the color attribute to set + * @param b blue component of the color attribute to set + */ + void SetColor(uint32_t index, float r, float g, float b); + + /** + * Sets a vertex's color attribute. + * @param index the vertex to set + * @param r red component of the color attribute to set + * @param g green component of the color attribute to set + * @param b blue component of the color attribute to set + * @param a alpha component of the color attribute to set + */ + void SetColor(uint32_t index, float r, float g, float b, float a); + + /** + * Sets a vertex's 3D position attribute. + * @param index the vertex to set + * @param position the new 3D position attribute to set + */ + void SetPosition3(uint32_t index, const Vector3 &position); + + /** + * Sets a vertex's 3D position attribute. + * @param index the vertex to set + * @param x X coordinate of the 3D position attribute to set + * @param y Y coordinate of the 3D position attribute to set + * @param z Z coordinate of the 3D position attribute to set + */ + void SetPosition3(uint32_t index, float x, float y, float z); + + /** + * Sets a vertex's 2D position attribute. + * @param index the vertex to set + * @param position the new 2D position attribute to set + */ + void SetPosition2(uint32_t index, const Vector2 &position); + + /** + * Sets a vertex's 2D position attribute. + * @param index the vertex to set + * @param x X coordinate of the 2D position attribute to set + * @param y Y coordinate of the 2D position attribute to set + */ + void SetPosition2(uint32_t index, float x, float y); + + /** + * Sets a vertex's normal attribute. + * @param index the vertex to set + * @param position the new normal attribute to set + */ + void SetNormal(uint32_t index, const Vector3 &normal); + + /** + * Sets a vertex's normal attribute. + * @param index the vertex to set + * @param x X coordinate of the normal attribute to set + * @param y Y coordinate of the normal attribute to set + * @param z Z coordinate of the normal attribute to set + */ + void SetNormal(uint32_t index, float x, float y, float z); + + /** + * Sets a vertex's texture coordinate attribute. + * @param index the vertex to set + * @param texCoord the new texture coordinate attribute to set + */ + void SetTexCoord(uint32_t index, const Vector2 &texCoord); + + /** + * Sets a vertex's texture coordinate attribute. + * @param index the vertex to set + * @param x U coordinate of the texture coordinate attribute to set + * @param y V coordinate of the texture coordinate attribute to set + */ + void SetTexCoord(uint32_t index, float x, float y); + + void Set1f(uint32_t attrib, uint32_t index, float x); + void Set2f(uint32_t attrib, uint32_t index, float x, float y); + void Set2f(uint32_t attrib, uint32_t index, const Vector2 &v); + void Set3f(uint32_t attrib, uint32_t index, float x, float y, float z); + void Set3f(uint32_t attrib, uint32_t index, const Vector3 &v); + void Set4f(uint32_t attrib, uint32_t index, float x, float y, float z, float w); + void Set4f(uint32_t attrib, uint32_t index, const Color &c); + void Set9f(uint32_t attrib, uint32_t index, const Matrix3x3 &m); + void Set16f(uint32_t attrib, uint32_t index, const Matrix4x4 &m); + + /** + * Sets the current vertex's color attribute. + * @param color the new color attribute to set + */ + void SetCurrentColor(const Color &color) { SetColor(GetCurrentPosition(), color); } + + /** + * Sets the current vertex's color attribute. + * @param r red component of the color attribute to set + * @param g green component of the color attribute to set + * @param b blue component of the color attribute to set + */ + void SetCurrentColor(float r, float g, float b) { SetColor(GetCurrentPosition(), r, g, b); } + + /** + * Sets the current vertex's color attribute. + * @param r red component of the color attribute to set + * @param g green component of the color attribute to set + * @param b blue component of the color attribute to set + * @param a alpha component of the color attribute to set + */ + void SetCurrentColor(float r, float g, float b, float a) { SetColor(GetCurrentPosition(), r, g, b, a); } + + /** + * Sets the current vertex's 3D position attribute. + * @param position the new 3D position attribute to set + */ + void SetCurrentPosition3(const Vector3 &position) { SetPosition3(GetCurrentPosition(), position); } + + /** + * Sets the current vertex's 3D position attribute. + * @param x X coordinate of the 3D position attribute to set + * @param y Y coordinate of the 3D position attribute to set + * @param z Z coordinate of the 3D position attribute to set + */ + void SetCurrentPosition3(float x, float y, float z) { SetPosition3(GetCurrentPosition(), x, y, z); } + + /** + * Sets the current vertex's 2D position attribute. + * @param position the new 2D position attribute to set + */ + void SetCurrentPosition2(const Vector2 &position) { SetPosition2(GetCurrentPosition(), position); } + + /** + * Sets the current vertex's 2D position attribute. + * @param x X coordinate of the 2D position attribute to set + * @param y Y coordinate of the 2D position attribute to set + */ + void SetCurrentPosition2(float x, float y) { SetPosition2(GetCurrentPosition(), x, y); } + + /** + * Sets the current vertex's normal attribute. + * @param position the new normal attribute to set + */ + void SetCurrentNormal(const Vector3 &normal) { SetNormal(GetCurrentPosition(), normal); } + + /** + * Sets the current vertex's normal attribute. + * @param x X coordinate of the normal attribute to set + * @param y Y coordinate of the normal attribute to set + * @param z Z coordinate of the normal attribute to set + */ + void SetCurrentNormal(float x, float y, float z) { SetNormal(GetCurrentPosition(), x, y, z); } + + /** + * Sets the current vertex's texture coordinate attribute. + * @param texCoord the new texture coordinate attribute to set + */ + void SetCurrentTexCoord(const Vector2 &texCoord) { SetTexCoord(GetCurrentPosition(), texCoord); } + + /** + * Sets the current vertex's texture coordinate attribute. + * @param x U coordinate of the texture coordinate attribute to set + * @param y V coordinate of the texture coordinate attribute to set + */ + void SetCurrentTexCoord(float x, float y) { SetTexCoord(GetCurrentPosition(), x, y); } + + void SetCurrent1f(uint32_t attrib, float x) { Set1f(attrib, GetCurrentPosition(), x); } + void SetCurrent2f(uint32_t attrib, float x, float y) { Set2f(attrib, GetCurrentPosition(), x, y); } + void SetCurrent2f(uint32_t attrib, const Vector2 &v) { Set2f(attrib, GetCurrentPosition(), v); } + void SetCurrent3f(uint32_t attrib, float x, float y, float z) { Set3f(attrib, GetCurrentPosition(), x, y, z); } + void SetCurrent3f(uint32_t attrib, const Vector3 &v) { Set3f(attrib, GetCurrentPosition(), v); } + void SetCurrent4f(uint32_t attrib, float x, float y, float z, float w) { Set4f(attrib, GetCurrentPosition(), x, y, z, w); } + void SetCurrent4f(uint32_t attrib, const Color &c) { Set4f(attrib, GetCurrentPosition(), c); } + void SetCurrent9f(uint32_t attrib, const Matrix3x3 &m) { Set9f(attrib, GetCurrentPosition(), m); } + void SetCurrent16f(uint32_t attrib, const Matrix4x4 &m) { Set16f(attrib, GetCurrentPosition(), m); } + + /** + * Moves the current vertex position to the next position. + * @return TRUE if the move succeeded, FALSE if there is no more vertices + * to move to after this one + */ + BOOL MoveNext(); + + /** + * Moves the current vertex position to the previous position. + * @return TRUE if the move succeeded, FALSE if there is no more vertices + * to move to before the current one + */ + BOOL MovePrevious(); + + /** + * Moves the current vertex position by the specified amount relative + * to the current position. + * @param numVertices the number of vertices to move. If this amount is + * greater then the remaining space left in the same + * direction, then it will be shrunk so as not to move + * out of bounds. + */ + void Move(int32_t numVertices); + + /** + * Moves the current vertex position to the beginning of the buffer. + */ + void MoveToStart() { m_currentVertex = 0; } + + /** + * Moves the current vertex position to the end of the buffer. + */ + void MoveToEnd() { m_currentVertex = GetNumElements() - 1; } + + /** + * Moves the current vertex position to the position specified. + * @param index the position to move to + */ + void MoveTo(uint32_t index) { m_currentVertex = index; } + + /** + * Resizes the buffer capacity to hold the specified number of vertices. + * @param numVertices the amount of vertices the buffer should be resized + * to hold + */ + void Resize(uint32_t numVertices); + + /** + * Extends the buffer capacity to hold the specified number of extra vertices. + * @param amount the amount of vertices to extend the buffer by + */ + void Extend(uint32_t amount); + + /** + * Copies vertices from a source buffer to this one. The copied vertices + * will be placed in this buffer beginning at the provided offset. + * @param source the source buffer to copy from + * @param destIndex the index of the vertex position in this buffer to + * start copying the vertices to + */ + void Copy(const VertexBuffer *source, uint32_t destIndex); + + /** + * @return the number of vertices contained in this buffer + */ + uint32_t GetNumElements() const { return m_numVertices; } + + /** + * @return the size in bytes of each vertex in this buffer object + */ + size_t GetElementWidthInBytes() const { return m_elementWidth * sizeof(float); } + + /** + * @return pointer to this buffer object's raw data + */ + const void* GetBuffer() const { return &m_buffer[0]; } + + /** + * @return the current position in the buffer + */ + uint32_t GetCurrentPosition() const { return m_currentVertex; } + + /** + * @return the number of vertex spaces left between the current position + * and the end of the buffer + */ + uint32_t GetRemainingSpace() const { return (GetNumElements() - 1) - GetCurrentPosition(); } + +private: + BOOL IsBufferAllocated() const { return m_buffer.size() > 0; } + + uint32_t GetVertexPosition(uint32_t index) const { return (index * m_elementWidth); } + uint32_t GetColorBufferPosition(uint32_t index) const { return GetVertexPosition(index) + m_colorOffset; } + uint32_t GetPosition3BufferPosition(uint32_t index) const { return GetVertexPosition(index) + m_position3Offset; } + uint32_t GetPosition2BufferPosition(uint32_t index) const { return GetVertexPosition(index) + m_position2Offset; } + uint32_t GetNormalBufferPosition(uint32_t index) const { return GetVertexPosition(index) + m_normalOffset; } + uint32_t GetTexCoordBufferPosition(uint32_t index) const { return GetVertexPosition(index) + m_texCoordOffset; } + uint32_t GetGenericBufferPosition(uint32_t attrib, uint32_t index) const { return GetVertexPosition(index) + m_attribs[attrib].offset; } + + uint32_t m_numVertices; + uint32_t m_currentVertex; + uint32_t m_standardTypeAttribs; + + // the below are all in terms of floats. multiply by sizeof(float) to get in bytes! + uint32_t m_elementWidth; + uint32_t m_colorOffset; + uint32_t m_position3Offset; + uint32_t m_position2Offset; + uint32_t m_normalOffset; + uint32_t m_texCoordOffset; + // --- + + stl::vector m_attribs; + uint32_t m_numGPUAttributeSlotsUsed; + stl::vector m_buffer; +}; + +inline BOOL VertexBuffer::AddAttribute(VERTEX_ATTRIB_SIZES size, VERTEX_ATTRIBS standardType) +{ + return AddAttribute((uint32_t)size, standardType); +} + +inline Color VertexBuffer::GetColor(uint32_t index) const +{ + uint32_t p = GetColorBufferPosition(index); + return Color( + m_buffer[p], + m_buffer[p + 1], + m_buffer[p + 2], + m_buffer[p + 3] + ); +} + +inline Vector3 VertexBuffer::GetPosition3(uint32_t index) const +{ + uint32_t p = GetPosition3BufferPosition(index); + return Vector3( + m_buffer[p], + m_buffer[p + 1], + m_buffer[p + 2] + ); +} + +inline Vector2 VertexBuffer::GetPosition2(uint32_t index) const +{ + uint32_t p = GetPosition2BufferPosition(index); + return Vector2( + m_buffer[p], + m_buffer[p + 1] + ); +} + +inline Vector3 VertexBuffer::GetNormal(uint32_t index) const +{ + uint32_t p = GetNormalBufferPosition(index); + return Vector3( + m_buffer[p], + m_buffer[p + 1], + m_buffer[p + 2] + ); +} + +inline Vector2 VertexBuffer::GetTexCoord(uint32_t index) const +{ + uint32_t p = GetTexCoordBufferPosition(index); + return Vector2( + m_buffer[p], + m_buffer[p + 1] + ); +} + +inline void VertexBuffer::Get1f(uint32_t attrib, uint32_t index, float &x) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + x = m_buffer[p]; +} + +inline float VertexBuffer::Get1f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + return m_buffer[p]; +} + +inline void VertexBuffer::Get2f(uint32_t attrib, uint32_t index, float &x, float &y) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + x = m_buffer[p]; + y = m_buffer[p + 1]; +} + +inline void VertexBuffer::Get2f(uint32_t attrib, uint32_t index, Vector2 &v) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + v.x = m_buffer[p]; + v.y = m_buffer[p + 1]; +} + +inline Vector2 VertexBuffer::Get2f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + return Vector2( + m_buffer[p], + m_buffer[p + 1] + ); +} + +inline void VertexBuffer::Get3f(uint32_t attrib, uint32_t index, float &x, float &y, float &z) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + x = m_buffer[p]; + y = m_buffer[p + 1]; + z = m_buffer[p + 2]; +} + +inline void VertexBuffer::Get3f(uint32_t attrib, uint32_t index, Vector3 &v) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + v.x = m_buffer[p]; + v.y = m_buffer[p + 1]; + v.z = m_buffer[p + 2]; +} + +inline Vector3 VertexBuffer::Get3f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + return Vector3( + m_buffer[p], + m_buffer[p + 1], + m_buffer[p + 2] + ); +} + +inline void VertexBuffer::Get4f(uint32_t attrib, uint32_t index, float &x, float &y, float &z, float &w) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + x = m_buffer[p]; + y = m_buffer[p + 1]; + z = m_buffer[p + 2]; + w = m_buffer[p + 3]; +} + +inline void VertexBuffer::Get4f(uint32_t attrib, uint32_t index, Color &c) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + c.r = m_buffer[p]; + c.g = m_buffer[p + 1]; + c.b = m_buffer[p + 2]; + c.a = m_buffer[p + 3]; +} + +inline Color VertexBuffer::Get4f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + return Color( + m_buffer[p], + m_buffer[p + 1], + m_buffer[p + 2], + m_buffer[p + 3] + ); +} + +inline void VertexBuffer::Get9f(uint32_t attrib, uint32_t index, Matrix3x3 &m) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + void *dest = m.m; + const void *src = &m_buffer[p]; + memcpy(dest, src, sizeof(float) * 9); +} + +inline Matrix3x3 VertexBuffer::Get9f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + Matrix3x3 m; + void *dest = m.m; + const void *src = &m_buffer[p]; + memcpy(dest, src, sizeof(float) * 9); + return m; +} + +inline void VertexBuffer::Get16f(uint32_t attrib, uint32_t index, Matrix4x4 &m) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + void *dest = m.m; + const void *src = &m_buffer[p]; + memcpy(dest, src, sizeof(float) * 16); +} + +inline Matrix4x4 VertexBuffer::Get16f(uint32_t attrib, uint32_t index) const +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + Matrix4x4 m; + void *dest = m.m; + const void *src = &m_buffer[p]; + memcpy(dest, src, sizeof(float) * 16); + return m; +} + +inline void VertexBuffer::SetColor(uint32_t index, const Color &color) +{ + uint32_t p = GetColorBufferPosition(index); + m_buffer[p] = color.r; + m_buffer[p + 1] = color.g; + m_buffer[p + 2] = color.b; + m_buffer[p + 3] = color.a; + SetDirty(); +} + +inline void VertexBuffer::SetColor(uint32_t index, float r, float g, float b) +{ + uint32_t p = GetColorBufferPosition(index); + m_buffer[p] = r; + m_buffer[p + 1] = g; + m_buffer[p + 2] = b; + m_buffer[p + 3] = COLOR_ALPHA_OPAQUE; + SetDirty(); +} + +inline void VertexBuffer::SetColor(uint32_t index, float r, float g, float b, float a) +{ + uint32_t p = GetColorBufferPosition(index); + m_buffer[p] = r; + m_buffer[p + 1] = g; + m_buffer[p + 2] = b; + m_buffer[p + 3] = a; + SetDirty(); +} + +inline void VertexBuffer::SetPosition3(uint32_t index, const Vector3 &position) +{ + uint32_t p = GetPosition3BufferPosition(index); + m_buffer[p] = position.x; + m_buffer[p + 1] = position.y; + m_buffer[p + 2] = position.z; + SetDirty(); +} + +inline void VertexBuffer::SetPosition3(uint32_t index, float x, float y, float z) +{ + uint32_t p = GetPosition3BufferPosition(index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + m_buffer[p + 2] = z; + SetDirty(); +} + +inline void VertexBuffer::SetPosition2(uint32_t index, const Vector2 &position) +{ + uint32_t p = GetPosition2BufferPosition(index); + m_buffer[p] = position.x; + m_buffer[p + 1] = position.y; + SetDirty(); +} + +inline void VertexBuffer::SetPosition2(uint32_t index, float x, float y) +{ + uint32_t p = GetPosition2BufferPosition(index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + SetDirty(); +} + +inline void VertexBuffer::SetNormal(uint32_t index, const Vector3 &normal) +{ + uint32_t p = GetNormalBufferPosition(index); + m_buffer[p] = normal.x; + m_buffer[p + 1] = normal.y; + m_buffer[p + 2] = normal.z; + SetDirty(); +} + +inline void VertexBuffer::SetNormal(uint32_t index, float x, float y, float z) +{ + uint32_t p = GetNormalBufferPosition(index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + m_buffer[p + 2] = z; + SetDirty(); +} + +inline void VertexBuffer::SetTexCoord(uint32_t index, const Vector2 &texCoord) +{ + uint32_t p = GetTexCoordBufferPosition(index); + m_buffer[p] = texCoord.x; + m_buffer[p + 1] = texCoord.y; + SetDirty(); +} + +inline void VertexBuffer::SetTexCoord(uint32_t index, float x, float y) +{ + uint32_t p = GetTexCoordBufferPosition(index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + SetDirty(); +} + +inline void VertexBuffer::Set1f(uint32_t attrib, uint32_t index, float x) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = x; + SetDirty(); +} + +inline void VertexBuffer::Set2f(uint32_t attrib, uint32_t index, float x, float y) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + SetDirty(); +} + +inline void VertexBuffer::Set2f(uint32_t attrib, uint32_t index, const Vector2 &v) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = v.x; + m_buffer[p + 1] = v.y; + SetDirty(); +} + +inline void VertexBuffer::Set3f(uint32_t attrib, uint32_t index, float x, float y, float z) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + m_buffer[p + 2] = z; + SetDirty(); +} + +inline void VertexBuffer::Set3f(uint32_t attrib, uint32_t index, const Vector3 &v) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = v.x; + m_buffer[p + 1] = v.y; + m_buffer[p + 2] = v.z; + SetDirty(); +} + +inline void VertexBuffer::Set4f(uint32_t attrib, uint32_t index, float x, float y, float z, float w) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = x; + m_buffer[p + 1] = y; + m_buffer[p + 2] = z; + m_buffer[p + 3] = w; + SetDirty(); +} + +inline void VertexBuffer::Set4f(uint32_t attrib, uint32_t index, const Color &c) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + m_buffer[p] = c.r; + m_buffer[p + 1] = c.g; + m_buffer[p + 2] = c.b; + m_buffer[p + 3] = c.a; + SetDirty(); +} + +inline void VertexBuffer::Set9f(uint32_t attrib, uint32_t index, const Matrix3x3 &m) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + void *dest = &m_buffer[p]; + const void *src = m.m; + memcpy(dest, src, sizeof(float) * 9); + SetDirty(); +} + +inline void VertexBuffer::Set16f(uint32_t attrib, uint32_t index, const Matrix4x4 &m) +{ + uint32_t p = GetGenericBufferPosition(attrib, index); + void *dest = &m_buffer[p]; + const void *src = m.m; + memcpy(dest, src, sizeof(float) * 16); + SetDirty(); +} + +inline BOOL VertexBuffer::MoveNext() +{ + ++m_currentVertex; + if (m_currentVertex >= GetNumElements()) + { + --m_currentVertex; + return FALSE; + } + else + return TRUE; +} + +inline BOOL VertexBuffer::MovePrevious() +{ + if (m_currentVertex == 0) + return FALSE; + else + { + --m_currentVertex; + return TRUE; + } +} + +inline void VertexBuffer::Move(int32_t numVertices) +{ + // m_currentVertex is unsigned, so detect when we would go negative beforehand + if (numVertices < 0 && (uint32_t)abs(numVertices) > m_currentVertex) + m_currentVertex = 0; + else + { + m_currentVertex += numVertices; + if (m_currentVertex >= GetNumElements()) + m_currentVertex = GetNumElements() - 1; + } +} + +#endif diff --git a/src/framework/graphics/vertexlerpshader.cpp b/src/framework/graphics/vertexlerpshader.cpp new file mode 100644 index 0000000..0f2e702 --- /dev/null +++ b/src/framework/graphics/vertexlerpshader.cpp @@ -0,0 +1,22 @@ +#include "../debug.h" + +#include "vertexlerpshader.h" + +VertexLerpShader::VertexLerpShader() + : StandardShader() +{ + STACK_TRACE; + SetLerpUniform("u_lerp"); +} + +VertexLerpShader::~VertexLerpShader() +{ + STACK_TRACE; +} + +void VertexLerpShader::SetLerp(float t) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_lerpUniform, t); +} diff --git a/src/framework/graphics/vertexlerpshader.h b/src/framework/graphics/vertexlerpshader.h new file mode 100644 index 0000000..c4d431c --- /dev/null +++ b/src/framework/graphics/vertexlerpshader.h @@ -0,0 +1,26 @@ +#ifndef __FRAMEWORK_GRAPHICS_VERTEXLERPSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_VERTEXLERPSHADER_H_INCLUDED__ + +#include "../common.h" +#include "standardshader.h" +#include + +class VertexLerpShader : public StandardShader +{ +public: + virtual ~VertexLerpShader(); + + void SetLerp(float t); + +protected: + VertexLerpShader(); + + const stl::string& GetLerpUniform() const { return m_lerpUniform; } + + void SetLerpUniform(const stl::string &name) { m_lerpUniform = name; } + +private: + stl::string m_lerpUniform; +}; + +#endif diff --git a/src/framework/graphics/vertexskinningshader.cpp b/src/framework/graphics/vertexskinningshader.cpp new file mode 100644 index 0000000..8e49221 --- /dev/null +++ b/src/framework/graphics/vertexskinningshader.cpp @@ -0,0 +1,32 @@ +#include "../debug.h" + +#include "vertexskinningshader.h" +#include "../math/quaternion.h" +#include "../math/vector3.h" + +VertexSkinningShader::VertexSkinningShader() + : StandardShader() +{ + STACK_TRACE; + SetJointPositionsUniform("u_jointPositions"); + SetJointRotationsUniform("u_jointRotations"); +} + +VertexSkinningShader::~VertexSkinningShader() +{ + STACK_TRACE; +} + +void VertexSkinningShader::SetJointPositions(const Vector3 *positions, uint32_t count) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_positionsUniform, positions, count); +} + +void VertexSkinningShader::SetJointRotations(const Quaternion *rotations, uint32_t count) +{ + STACK_TRACE; + ASSERT(IsReadyForUse() == TRUE); + SetUniform(m_rotationsUniform, rotations, count); +} diff --git a/src/framework/graphics/vertexskinningshader.h b/src/framework/graphics/vertexskinningshader.h new file mode 100644 index 0000000..5a9b313 --- /dev/null +++ b/src/framework/graphics/vertexskinningshader.h @@ -0,0 +1,33 @@ +#ifndef __FRAMEWORK_GRAPHICS_VERTEXSKINNINGSHADER_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_VERTEXSKINNINGSHADER_H_INCLUDED__ + +#include "../common.h" +#include "standardshader.h" +#include + +struct Quaternion; +struct Vector3; + +class VertexSkinningShader : public StandardShader +{ +public: + virtual ~VertexSkinningShader(); + + void SetJointPositions(const Vector3 *positions, uint32_t count); + void SetJointRotations(const Quaternion *rotations, uint32_t count); + +protected: + VertexSkinningShader(); + + const stl::string& GetJointPositionsUniform() const { return m_positionsUniform; } + const stl::string& GetJointRotationsUniform() const { return m_rotationsUniform; } + + void SetJointPositionsUniform(const stl::string &name) { m_positionsUniform = name; } + void SetJointRotationsUniform(const stl::string &name) { m_rotationsUniform = name; } + +private: + stl::string m_positionsUniform; + stl::string m_rotationsUniform; +}; + +#endif diff --git a/src/framework/graphics/viewcontext.cpp b/src/framework/graphics/viewcontext.cpp new file mode 100644 index 0000000..7a2ba0e --- /dev/null +++ b/src/framework/graphics/viewcontext.cpp @@ -0,0 +1,253 @@ +#include "../debug.h" + +#include "viewcontext.h" +#include "../common.h" +#include "../gamewindow.h" +#include "../screenorientation.h" +#include "../graphics/glincludes.h" +#include "../graphics/glutils.h" +#include "../graphics/graphicsdevice.h" +#include "../math/camera.h" +#include "../math/mathhelpers.h" +#include "../math/matrix4x4.h" +#include "../math/matrixstack.h" +#include "../math/rect.h" + +ViewContext::ViewContext() +{ + STACK_TRACE; + m_graphicsDevice = NULL; + m_viewport = Rect(0, 0, 0, 0); + m_viewportIsFixedSize = FALSE; + m_camera = NULL; + m_usingDefaultCamera = FALSE; +} + +ViewContext::~ViewContext() +{ + STACK_TRACE; + Release(); +} + +void ViewContext::Release() +{ + STACK_TRACE; + if (m_usingDefaultCamera) + SAFE_DELETE(m_camera); + + m_graphicsDevice = NULL; + m_viewport = Rect(0, 0, 0, 0); + m_viewportIsFixedSize = FALSE; + m_screenOrientation = SCREEN_ANGLE_0; + m_camera = NULL; + m_usingDefaultCamera = FALSE; +} + +BOOL ViewContext::Create(GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + ASSERT(m_graphicsDevice == NULL); + if (m_graphicsDevice != NULL) + return FALSE; + + ASSERT(graphicsDevice != NULL); + m_graphicsDevice = graphicsDevice; + + m_viewport = m_graphicsDevice->GetWindow()->GetRect(); + m_viewportIsFixedSize = FALSE; + m_screenOrientation = SCREEN_ANGLE_0; + + m_camera = new Camera(this); + m_usingDefaultCamera = TRUE; + + return TRUE; +} + +BOOL ViewContext::Create(GraphicsDevice *graphicsDevice, const Rect &fixedViewportSize) +{ + STACK_TRACE; + ASSERT(m_graphicsDevice == NULL); + if (m_graphicsDevice != NULL) + return FALSE; + + ASSERT(graphicsDevice != NULL); + m_graphicsDevice = graphicsDevice; + + m_viewport = fixedViewportSize; + m_viewportIsFixedSize = TRUE; + m_screenOrientation = SCREEN_ANGLE_0; + + m_camera = new Camera(this); + m_usingDefaultCamera = TRUE; + + return TRUE; +} + +void ViewContext::OnNewContext() +{ + STACK_TRACE; + m_modelviewStack.Clear(); + m_modelviewStack.top = IDENTITY_MATRIX; + m_projectionStack.Clear(); + m_projectionStack.top = IDENTITY_MATRIX; +} + +void ViewContext::OnLostContext() +{ + STACK_TRACE; +} + +void ViewContext::OnResize(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation) +{ + STACK_TRACE; + SetupViewport(size, screenOrientation); +} + +void ViewContext::OnRender() +{ + STACK_TRACE; + if (m_camera != NULL) + m_camera->OnRender(); +} + +void ViewContext::OnApply(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation) +{ + STACK_TRACE; + SetupViewport(size, screenOrientation); + + // ensures it's set up for rendering immediately when this call returns + // NOTE: we assume OnApply() is going to be called in some other class's + // OnRender() event only (like, e.g. if a new framebuffer is bound) + if (m_camera != NULL) + m_camera->OnRender(); +} + +void ViewContext::SetProjectionMatrix(const Matrix4x4 &m) +{ + STACK_TRACE; + if (!IgnoringScreenRotation() && m_screenOrientation != SCREEN_ANGLE_0) + { + // apply a rotation immediately _after_ the projection matrix transform + float angle = (float)m_screenOrientation; + Matrix4x4 adjusted = Matrix4x4::CreateRotationZ(-DegreesToRadians(angle)) * m; + m_projectionStack.top = adjusted; + } + else + m_projectionStack.top = m; +} + +void ViewContext::PushProjectionMatrix() +{ + STACK_TRACE; + m_projectionStack.Push(); + // with MatrixStack, pushing does not change the top matrix, so + // we don't need to re-set the projection matrix with OpenGL +} + +void ViewContext::PopProjectionMatrix() +{ + STACK_TRACE; + m_projectionStack.Pop(); +} + +Matrix4x4 ViewContext::GetOrthographicProjectionMatrix() +{ + STACK_TRACE; + Matrix4x4 ortho = Matrix4x4::CreateOrthographic((float)m_viewport.left, (float)m_viewport.right, (float)m_viewport.top, (float)m_viewport.bottom, 0.0f, 1.0f); + + if (!IgnoringScreenRotation() && m_screenOrientation != SCREEN_ANGLE_0) + { + // apply a rotation immediately _after_ the projection matrix transform + float angle = (float)m_screenOrientation; + Matrix4x4 adjusted = Matrix4x4::CreateRotationZ(-DegreesToRadians(angle)) * ortho; + return adjusted; + } + else + return ortho; +} + +void ViewContext::SetModelViewMatrix(const Matrix4x4 &m) +{ + STACK_TRACE; + m_modelviewStack.top = m; +} + +void ViewContext::PushModelViewMatrix() +{ + STACK_TRACE; + m_modelviewStack.Push(); + // with MatrixStack, pushing does not change the top matrix, so + // we don't need to re-set the modelview matrix with OpenGL +} + +void ViewContext::PopModelViewMatrix() +{ + STACK_TRACE; + m_modelviewStack.Pop(); +} + +void ViewContext::SetCamera(Camera *camera) +{ + STACK_TRACE; + // using the default camera but a new camera is being provided? + if (m_usingDefaultCamera && camera != NULL) + { + SAFE_DELETE(m_camera); + m_usingDefaultCamera = FALSE; + m_camera = camera; + } + + // not using the default camera already, but setting a new camera + else if (!m_usingDefaultCamera && camera != NULL) + { + m_camera = camera; + } + + // not using the default camera, and clearing ("nulling") the camera + else if (!m_usingDefaultCamera && camera == NULL) + { + m_camera = new Camera(this); + ASSERT(m_camera != NULL); + m_usingDefaultCamera = TRUE; + } +} + +void ViewContext::SetupViewport(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation) +{ + STACK_TRACE; + Rect viewport; + + if (m_viewportIsFixedSize) + { + viewport = m_viewport; + m_screenOrientation = SCREEN_ANGLE_0; + } + else + { + // based on the orientation, we may need to swap the width/height + // of the passed viewport dimensions + // (we don't do viewport rotation if the viewport is fixed) + if (!IgnoringScreenRotation() && (screenOrientation == SCREEN_ANGLE_90 || screenOrientation == SCREEN_ANGLE_270)) + { + // swap width and height + viewport.left = size.top; + viewport.top = size.left; + viewport.right = size.bottom; + viewport.bottom = size.right; + } + else + viewport = size; + + // we **don't** want this to be rotated + m_viewport = size; + + m_screenOrientation = screenOrientation; + } + + // we **do** obviously want this to be rotated (if there is a rotation) + GL_CALL(glViewport(viewport.left, viewport.top, viewport.GetWidth(), viewport.GetHeight())); + + // we also **don't** want the camera to work with a rotated viewport + if (m_camera != NULL) + m_camera->OnResize(m_viewport); +} diff --git a/src/framework/graphics/viewcontext.h b/src/framework/graphics/viewcontext.h new file mode 100644 index 0000000..356483b --- /dev/null +++ b/src/framework/graphics/viewcontext.h @@ -0,0 +1,69 @@ +#ifndef __FRAMEWORK_GRAPHICS_VIEWCONTEXT_H_INCLUDED__ +#define __FRAMEWORK_GRAPHICS_VIEWCONTEXT_H_INCLUDED__ + +#include "../common.h" +#include "../math/matrix4x4.h" +#include "../math/matrixstack.h" +#include "../math/rect.h" +#include "../screenorientation.h" + +class Camera; +class GraphicsDevice; + +class ViewContext +{ +public: + ViewContext(); + virtual ~ViewContext(); + + BOOL Create(GraphicsDevice *graphicsDevice); + BOOL Create(GraphicsDevice *graphicsDevice, const Rect &fixedViewportSize); + void Release(); + + void OnNewContext(); + void OnLostContext(); + void OnResize(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation = SCREEN_ANGLE_0); + void OnRender(); + void OnApply(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation = SCREEN_ANGLE_0); + + Matrix4x4 GetProjectionMatrix() const { return m_projectionStack.top; } + void SetProjectionMatrix(const Matrix4x4 &m); + void PushProjectionMatrix(); + void PopProjectionMatrix(); + Matrix4x4 GetOrthographicProjectionMatrix(); + + Matrix4x4 GetModelViewMatrix() const { return m_modelviewStack.top; } + void SetModelViewMatrix(const Matrix4x4 &m); + void PushModelViewMatrix(); + void PopModelViewMatrix(); + + Camera* GetCamera() const { return m_camera; } + void SetCamera(Camera *camera); + + uint16_t GetViewportTop() const { return (uint16_t)m_viewport.top; } + uint16_t GetViewportLeft() const { return (uint16_t)m_viewport.left; } + uint16_t GetViewportBottom() const { return (uint16_t)m_viewport.bottom; } + uint16_t GetViewportRight() const { return (uint16_t)m_viewport.right; } + uint16_t GetViewportWidth() const { return (uint16_t)m_viewport.GetWidth(); } + uint16_t GetViewportHeight() const { return (uint16_t)m_viewport.GetHeight(); } + + BOOL IsViewportFixedSize() const { return m_viewportIsFixedSize; } + BOOL IgnoringScreenRotation() const { return m_viewportIsFixedSize; } + +private: + void SetupViewport(const Rect &size, SCREEN_ORIENTATION_ANGLE screenOrientation); + + GraphicsDevice *m_graphicsDevice; + + Rect m_viewport; + BOOL m_viewportIsFixedSize; + SCREEN_ORIENTATION_ANGLE m_screenOrientation; + + Camera *m_camera; + BOOL m_usingDefaultCamera; + + MatrixStack m_modelviewStack; + MatrixStack m_projectionStack; +}; + +#endif diff --git a/src/framework/gwen/gwen_inputprocessor.cpp b/src/framework/gwen/gwen_inputprocessor.cpp new file mode 100644 index 0000000..da62ce3 --- /dev/null +++ b/src/framework/gwen/gwen_inputprocessor.cpp @@ -0,0 +1,207 @@ +#include "../debug.h" + +#include "gwen_inputprocessor.h" +#include +#include "../basegameapp.h" +#include "../input/keyboard.h" +#include "../input/keysyms.h" +#include "../input/mouse.h" +#include "../input/mousebuttons.h" +#include "../input/touchscreen.h" + +namespace Gwen +{ + namespace Input + { + InputProcessor::InputProcessor(BaseGameApp *gameApp, Gwen::Controls::Canvas *canvas) + { + STACK_TRACE; + m_gameApp = gameApp; + m_canvas = canvas; + m_enabled = FALSE; + + Enable(TRUE); + } + + InputProcessor::~InputProcessor() + { + STACK_TRACE; + Enable(FALSE); + } + + BOOL InputProcessor::OnKeyDown(KEYS key) + { + unsigned char gwenKey = ConvertToGwenKey(key); + return (BOOL)m_canvas->InputKey(gwenKey, TRUE); + } + + BOOL InputProcessor::OnKeyUp(KEYS key) + { + unsigned char gwenKey = ConvertToGwenKey(key); + return (BOOL)m_canvas->InputKey(gwenKey, FALSE); + } + + BOOL InputProcessor::OnMouseButtonDown(MOUSE_BUTTONS button, uint16_t x, uint16_t y) + { + int gwenButton = ConvertToGwenButton(button); + + int scaledX = (float)x / m_canvas->Scale(); + int scaledY = (float)y / m_canvas->Scale(); + + // trigger mouse move event for button events to ensure GWEN + // knows where the button event occured at + BOOL movedResult = (BOOL)m_canvas->InputMouseMoved(scaledX, scaledY, 0, 0); + BOOL clickResult = (BOOL)m_canvas->InputMouseButton(gwenButton, TRUE); + + // TODO: is this really the right way to do this .. ? + return (movedResult || clickResult); + } + + BOOL InputProcessor::OnMouseButtonUp(MOUSE_BUTTONS button, uint16_t x, uint16_t y) + { + int gwenButton = ConvertToGwenButton(button); + + int scaledX = (float)x / m_canvas->Scale(); + int scaledY = (float)y / m_canvas->Scale(); + + // trigger mouse move event for button events to ensure GWEN + // knows where the button event occured at + BOOL movedResult = (BOOL)m_canvas->InputMouseMoved(scaledX, scaledY, 0, 0); + BOOL clickResult = (BOOL)m_canvas->InputMouseButton(gwenButton, FALSE); + + // TODO: is this really the right way to do this .. ? + return (movedResult || clickResult); + } + + BOOL InputProcessor::OnMouseMove(uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY) + { + // Gwen's input handling only processes coordinates in terms of scale = 1.0f + int scaledX = (float)x / m_canvas->Scale(); + int scaledY = (float)y / m_canvas->Scale(); + int scaledDeltaX = (float)deltaX / m_canvas->Scale(); + int scaledDeltaY = (float)deltaY / m_canvas->Scale(); + + return (BOOL)m_canvas->InputMouseMoved(scaledX, scaledY, scaledDeltaX, scaledDeltaY); + } + + BOOL InputProcessor::OnTouchDown(int32_t id, uint16_t x, uint16_t y, BOOL isPrimary) + { + if (!isPrimary) + return FALSE; + + // Gwen's input handling only processes coordinates in terms of scale = 1.0f + int scaledX = (float)x / m_canvas->Scale(); + int scaledY = (float)y / m_canvas->Scale(); + + BOOL movedResult = (BOOL)m_canvas->InputMouseMoved(scaledX, scaledY, 0, 0); + BOOL clickResult = (BOOL)m_canvas->InputMouseButton(0, TRUE); + + // TODO: is this really the right way to do this .. ? + return (movedResult || clickResult); + } + + BOOL InputProcessor::OnTouchUp(int32_t id, BOOL isPrimary) + { + if (!isPrimary) + return FALSE; + + BOOL clickResult = (BOOL)m_canvas->InputMouseButton(0, FALSE); + + // we do this so that GWEN isn't left thinking that the "mouse" is + // hovering over whatever we were just clicking/touching. This is + // done because obviously with a touchscreen, you don't hover over + // anything unless you are clicking/touching... + BOOL movedResult = (BOOL)m_canvas->InputMouseMoved(-1, -1, 0, 0); + + // TODO: is this really the right way to do this .. ? + return (movedResult || clickResult); + } + + BOOL InputProcessor::OnTouchMove(int32_t id, uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY, BOOL isPrimary) + { + if (!isPrimary) + return FALSE; + + // Gwen's input handling only processes coordinates in terms of scale = 1.0f + int scaledX = (float)x / m_canvas->Scale(); + int scaledY = (float)y / m_canvas->Scale(); + int scaledDeltaX = (float)deltaX / m_canvas->Scale(); + int scaledDeltaY = (float)deltaY / m_canvas->Scale(); + + BOOL movedResult = (BOOL)m_canvas->InputMouseMoved(scaledX, scaledY, scaledDeltaX, scaledDeltaY); + BOOL clickResult = (BOOL)m_canvas->InputMouseButton(0, TRUE); + + // TODO: is this really the right way to do this .. ? + return (movedResult || clickResult); + } + + void InputProcessor::Enable(BOOL enable) + { + if (IsEnabled() == enable) + return; + + Keyboard *keyboard = m_gameApp->GetKeyboard(); + Mouse *mouse = m_gameApp->GetMouse(); + Touchscreen *touchscreen = m_gameApp->GetTouchscreen(); + + if (enable) + { + if (keyboard != NULL) + keyboard->RegisterListener(this); + if (mouse != NULL) + mouse->RegisterListener(this); + if (touchscreen != NULL) + touchscreen->RegisterListener(this); + } + else + { + if (keyboard != NULL) + keyboard->UnregisterListener(this); + if (mouse != NULL) + mouse->UnregisterListener(this); + if (touchscreen != NULL) + touchscreen->UnregisterListener(this); + } + + m_enabled = enable; + } + + unsigned char InputProcessor::ConvertToGwenKey(KEYS key) const + { + switch (key) + { + case KSYM_BACKSPACE: return Gwen::Key::Backspace; + case KSYM_ESCAPE: return Gwen::Key::Escape; + case KSYM_END: return Gwen::Key::End; + case KSYM_LCTRL: return Gwen::Key::Control; + case KSYM_RCTRL: return Gwen::Key::Control; + case KSYM_RETURN: return Gwen::Key::Return; + case KSYM_TAB: return Gwen::Key::Tab; + case KSYM_SPACE: return Gwen::Key::Space; + case KSYM_UP: return Gwen::Key::Up; + case KSYM_DOWN: return Gwen::Key::Down; + case KSYM_LEFT: return Gwen::Key::Left; + case KSYM_RIGHT: return Gwen::Key::Right; + case KSYM_HOME: return Gwen::Key::Home; + case KSYM_DELETE: return Gwen::Key::Delete; + case KSYM_LALT: return Gwen::Key::Alt; + case KSYM_LSHIFT: return Gwen::Key::Shift; + case KSYM_RALT: return Gwen::Key::Alt; + case KSYM_RSHIFT: return Gwen::Key::Shift; + default: return Gwen::Key::Invalid; + } + } + + int InputProcessor::ConvertToGwenButton(MOUSE_BUTTONS button) const + { + switch (button) + { + case MOUSE_LEFT: return 0; + case MOUSE_MIDDLE: return 2; + case MOUSE_RIGHT: return 1; + default: return -1; // TODO: is this ok for an invalid value? would it be better to return some other default ... ? + } + } + } +} + diff --git a/src/framework/gwen/gwen_inputprocessor.h b/src/framework/gwen/gwen_inputprocessor.h new file mode 100644 index 0000000..a6adbe2 --- /dev/null +++ b/src/framework/gwen/gwen_inputprocessor.h @@ -0,0 +1,48 @@ +#ifndef __FRAMEWORK_GWEN_GWEN_INPUTPROCESSOR_H_INCLUDED__ +#define __FRAMEWORK_GWEN_GWEN_INPUTPROCESSOR_H_INCLUDED__ + +#include "../common.h" +#include "../input/keyboardlistener.h" +#include "../input/mouselistener.h" +#include "../input/touchscreenlistener.h" +#include + +class BaseGameApp; + +namespace Gwen +{ + namespace Input + { + class InputProcessor : public KeyboardListener, public MouseListener, public TouchscreenListener + { + public: + InputProcessor(BaseGameApp *gameApp, Gwen::Controls::Canvas *canvas); + virtual ~InputProcessor(); + + BOOL OnKeyDown(KEYS key); + BOOL OnKeyUp(KEYS key); + + BOOL OnMouseButtonDown(MOUSE_BUTTONS button, uint16_t x, uint16_t y); + BOOL OnMouseButtonUp(MOUSE_BUTTONS button, uint16_t x, uint16_t y); + BOOL OnMouseMove(uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY); + + BOOL OnTouchDown(int32_t id, uint16_t x, uint16_t y, BOOL isPrimary); + BOOL OnTouchUp(int32_t id, BOOL isPrimary); + BOOL OnTouchMove(int32_t id, uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY, BOOL isPrimary); + + BOOL IsEnabled() const { return m_enabled; } + void Enable(BOOL enable); + + private: + unsigned char ConvertToGwenKey(KEYS key) const; + int ConvertToGwenButton(MOUSE_BUTTONS button) const; + + BaseGameApp *m_gameApp; + Gwen::Controls::Canvas *m_canvas; + BOOL m_enabled; + }; + } +} + +#endif + diff --git a/src/framework/gwen/gwen_spritebatchrenderer.cpp b/src/framework/gwen/gwen_spritebatchrenderer.cpp new file mode 100644 index 0000000..2d2b87c --- /dev/null +++ b/src/framework/gwen/gwen_spritebatchrenderer.cpp @@ -0,0 +1,221 @@ +#include "../debug.h" +#include "../log.h" + +#include "../common.h" +#include "gwen_spritebatchrenderer.h" +#include +#include +#include +#include +#include +#include "../content/contentmanager.h" +#include "../content/spritefontparam.h" +#include "../graphics/color.h" +#include "../graphics/graphicsdevice.h" +#include "../graphics/image.h" +#include "../graphics/spritebatch.h" +#include "../graphics/spritefont.h" +#include "../graphics/texture.h" +#include + +#define LOGCAT_GWENUI "GWENUI" + +namespace Gwen +{ + namespace Renderer + { + SpriteBatchRenderer::SpriteBatchRenderer(ContentManager *contentManager, GraphicsDevice *graphicsDevice) + { + m_spriteBatch = NULL; + m_contentManager = contentManager; + m_graphicsDevice = graphicsDevice; + m_alpha = COLOR_ALPHA_OPAQUE; + } + + SpriteBatchRenderer::~SpriteBatchRenderer() + { + } + + void SpriteBatchRenderer::PreRender(SpriteBatch *spriteBatch) + { + m_spriteBatch = spriteBatch; + } + + void SpriteBatchRenderer::PostRender() + { + m_spriteBatch = NULL; + } + + void SpriteBatchRenderer::Begin() + { + ASSERT(m_spriteBatch != NULL); + Gwen::Renderer::Base::Begin(); + } + + void SpriteBatchRenderer::End() + { + Gwen::Renderer::Base::End(); + } + + void SpriteBatchRenderer::SetDrawColor(Gwen::Color color) + { + m_color = ::Color(color.r, color.g, color.b, color.a); + } + + void SpriteBatchRenderer::DrawFilledRect(Gwen::Rect rect) + { + Translate(rect); + + ::Color renderColor = AdjustColorForAlpha(m_color); + ::Texture *colorTexture = m_graphicsDevice->GetSolidColorTexture(renderColor); + + m_spriteBatch->Render(colorTexture, rect.x, rect.y, rect.w, rect.h); + } + + void SpriteBatchRenderer::StartClip() + { + ASSERT(m_spriteBatch != NULL); + Gwen::Rect rect = ClipRegion(); + + int16_t left = (int16_t)((float)rect.x * Scale()); + int16_t top = (int16_t)((float)rect.y * Scale()); + int16_t right = (int16_t)((float)(rect.x + rect.w) * Scale()); + int16_t bottom = (int16_t)((float)(rect.y + rect.h) * Scale()); + + m_spriteBatch->SetClipRegion(left, top, right, bottom); + } + + void SpriteBatchRenderer::EndClip() + { + ASSERT(m_spriteBatch != NULL); + m_spriteBatch->ClearClipRegion(); + } + + void SpriteBatchRenderer::LoadTexture(Gwen::Texture *pTexture) + { + const stl::string textureFilename = pTexture->name.Get(); + LOG_INFO(LOGCAT_GWENUI, "Gwen::Renderer::SpriteBatchRenderer loading texture \"%s\"\n", textureFilename.c_str()); + ::Texture *texture = m_contentManager->Get< ::Texture>(textureFilename); + ASSERT(texture != NULL); + + pTexture->data = texture; + pTexture->width = texture->GetWidth(); + pTexture->height = texture->GetHeight(); + } + + void SpriteBatchRenderer::FreeTexture(Gwen::Texture *pTexture) + { + const stl::string textureFilename = pTexture->name.Get(); + ::Texture *texture = (::Texture*)pTexture->data; + ASSERT(texture != NULL); + + if (textureFilename.size() == 0) + LOG_INFO(LOGCAT_GWENUI, "Gwen::Renderer::SpriteBatchRenderer not freeing texture ID %d. Has empty name property, was not loaded by us.\n", texture->GetTextureName()); + else + { + LOG_INFO(LOGCAT_GWENUI, "Gwen::Renderer::SpriteBatchRenderer freeing texture \"%s\"\n", textureFilename.c_str()); + m_contentManager->Free< ::Texture>(texture); + } + } + + void SpriteBatchRenderer::DrawTexturedRect(Gwen::Texture *pTexture, Gwen::Rect pTargetRect, float u1, float v1, float u2, float v2) + { + Translate(pTargetRect); + ::Texture *texture = (::Texture*)pTexture->data; + ASSERT(texture != NULL); + + ::Color renderColor = AdjustColorForAlpha(::Color(1.0f, 1.0f, 1.0f)); + + m_spriteBatch->Render(texture, pTargetRect.x, pTargetRect.y, pTargetRect.w, pTargetRect.h, u1, v1, u2, v2, renderColor); + } + + Gwen::Color SpriteBatchRenderer::PixelColour(Gwen::Texture *pTexture, unsigned int x, unsigned int y, const Gwen::Color &col_default) + { + // HACK: sloppy, figure out a better way + // although this is possibly not that terrible since using + // ContentManager to load an image will cause the + // ContentLoader object to cache the image for subsequent + // access... the only real problem is that the image will be + // loaded twice per SpriteBatchRenderer instance (LoadTexture + this) + // and that right now we don't free the image + // Should probably have an std::list of Image objects to be freed + // in the destructor + const stl::string textureFilename = pTexture->name.Get(); + Image *image = m_contentManager->Get(textureFilename); + ASSERT(image != NULL); + + ::Color pixelColor = image->GetColor(x, y); + + Gwen::Color result; + pixelColor.ToInts(&result.r, &result.g, &result.b, &result.a); + return result; + } + + void SpriteBatchRenderer::LoadFont(Gwen::Font *pFont) + { + LOG_INFO(LOGCAT_GWENUI, "Gwen::Renderer::SpriteBatchRenderer loading font \"%s\"\n", pFont->facename.c_str()); + SpriteFontParam fontParam((uint8_t)pFont->size); + SpriteFont *font = m_contentManager->Get(pFont->facename, fontParam); + ASSERT(font != NULL); + + pFont->data = font; + } + + void SpriteBatchRenderer::FreeFont(Gwen::Font *pFont) + { + // HACK: apparently this can get called when some set of UI elements + // is set up and then later freed, but no fonts were ever + // rendered vi GWEN. In this case, pFont->data will be NULL... + if (pFont->data == NULL) + return; + + LOG_INFO(LOGCAT_GWENUI, "Gwen::Renderer::SpriteBatchRenderer freeing font \"%s\"\n", pFont->facename.c_str()); + SpriteFont *font = (SpriteFont*)pFont->data; + ASSERT(font != NULL); + + m_contentManager->Free(font); + } + + void SpriteBatchRenderer::RenderText(Gwen::Font *pFont, Gwen::Point pos, const Gwen::String &text) + { + Translate(pos.x, pos.y); + SpriteFont *font = (SpriteFont*)pFont->data; + ASSERT(font != NULL); + + ::Color renderColor = AdjustColorForAlpha(m_color); + + m_spriteBatch->Render(font, pos.x, pos.y, renderColor, Scale(), text.c_str()); + } + + Gwen::Point SpriteBatchRenderer::MeasureText(Gwen::Font *pFont, const Gwen::String &text) + { + SpriteFont *font = (SpriteFont*)pFont->data; + + // HACK: is this supposed to work this way? seems that MeasureText + // can (and will) get called from Gwen's classes before a call + // to LoadFont is made... + if (font == NULL) + { + LoadFont(pFont); + font = (SpriteFont*)pFont->data; + } + + ASSERT(font != NULL); + + uint16_t width = 0; + uint16_t height = 0; + font->MeasureString(&width, &height, text.c_str()); + + Gwen::Point result(width, height); + return result; + } + + ::Color SpriteBatchRenderer::AdjustColorForAlpha(const ::Color &color) const + { + ::Color result = color; + result.a *= m_alpha; + return result; + } + } +} + diff --git a/src/framework/gwen/gwen_spritebatchrenderer.h b/src/framework/gwen/gwen_spritebatchrenderer.h new file mode 100644 index 0000000..36064c2 --- /dev/null +++ b/src/framework/gwen/gwen_spritebatchrenderer.h @@ -0,0 +1,66 @@ +#ifndef __FRAMEWORK_GWEN_GWEN_SPRITEBATCHRENDERER_H_INCLUDED__ +#define __FRAMEWORK_GWEN_GWEN_SPRITEBATCHRENDERER_H_INCLUDED__ + +#include +#include "../graphics/color.h" + +class ContentManager; +class GraphicsDevice; +class SpriteBatch; + +namespace Gwen +{ + struct Color; + struct Font; + struct Point; + struct Rect; + struct Texture; + + namespace Renderer + { + class SpriteBatchRenderer : public Gwen::Renderer::Base + { + public: + SpriteBatchRenderer(ContentManager *contentManager, GraphicsDevice *graphicsDevice); + virtual ~SpriteBatchRenderer(); + + void PreRender(SpriteBatch *spriteBatch); + void PostRender(); + + void Begin(); + void End(); + + void SetDrawColor(Gwen::Color color); + + void DrawFilledRect(Gwen::Rect rect); + + void StartClip(); + void EndClip(); + + void LoadTexture(Gwen::Texture *pTexture); + void FreeTexture(Gwen::Texture *pTexture); + void DrawTexturedRect(Gwen::Texture *pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f); + Gwen::Color PixelColour(Gwen::Texture *pTexture, unsigned int x, unsigned int y, const Gwen::Color &col_default = Gwen::Color(255, 255, 255, 255)); + + void LoadFont(Gwen::Font *pFont); + void FreeFont(Gwen::Font *pFont); + void RenderText(Gwen::Font *pFont, Gwen::Point pos, const Gwen::String &text); + Gwen::Point MeasureText(Gwen::Font *pFont, const Gwen::String &text); + + float GetAlpha() const { return m_alpha; } + void SetAlpha(float alpha) { m_alpha = alpha; } + + private: + ::Color AdjustColorForAlpha(const ::Color &color) const; + + ContentManager *m_contentManager; + GraphicsDevice *m_graphicsDevice; + SpriteBatch *m_spriteBatch; + ::Color m_color; + float m_alpha; + }; + } +} + +#endif + diff --git a/src/framework/input/keyboard.h b/src/framework/input/keyboard.h new file mode 100644 index 0000000..95d6535 --- /dev/null +++ b/src/framework/input/keyboard.h @@ -0,0 +1,67 @@ +#ifndef __FRAMEWORK_INPUT_KEYBOARD_H_INCLUDED__ +#define __FRAMEWORK_INPUT_KEYBOARD_H_INCLUDED__ + +#include "../common.h" +#include "keysyms.h" + +class KeyboardListener; + +/** + * Interface for a keyboard input device class. + */ +class Keyboard +{ +public: + Keyboard() {} + virtual ~Keyboard() {} + + /** + * @return TRUE if the underlying keyboard device was detected to have + * enough physical keys for full game control + */ + virtual BOOL HasPhysicalKeysForGameControls() const = 0; + + /** + * Checks if the key is currently down, but not locked. + * @param key the key to check + * @return TRUE if down and not locked, FALSE if not down or locked + */ + virtual BOOL IsDown(KEYS key) = 0; + + /** + * Checks if the key is currently down, but not locked. If so, the key is + * locked until released so that duplicate "down" events will not be + * registered for this key until it is released and pressed down again. + * @param key the key to check + * @return TRUE if down and not locked, FALSE if not down or locked + */ + virtual BOOL IsPressed(KEYS key) = 0; + + /** + * Locks the key so that it will not be reported as down until it is + * released and then pressed down again. + * @param key the key to lock + */ + virtual void Lock(KEYS key) = 0; + + /** + * Resets the current key states and locked key states. + */ + virtual void Reset() = 0; + + /** + * Registers a keyboard event listener so that keyboard events will be + * sent to it. + * @param listener the listener object to register + */ + virtual void RegisterListener(KeyboardListener *listener) = 0; + + /** + * Unregisters a keyboard event listener so that keyboard events will no + * longer be sent to it. + * @param listener the listener object to unregister + */ + virtual void UnregisterListener(KeyboardListener *listener) = 0; +}; + +#endif diff --git a/src/framework/input/keyboardlistener.h b/src/framework/input/keyboardlistener.h new file mode 100644 index 0000000..70a820c --- /dev/null +++ b/src/framework/input/keyboardlistener.h @@ -0,0 +1,31 @@ +#ifndef __FRAMEWORK_INPUT_KEYBOARDLISTENER_H_INCLUDED__ +#define __FRAMEWORK_INPUT_KEYBOARDLISTENER_H_INCLUDED__ + +#include "keysyms.h" + +/** + * Interface for objects that want to receive callbacks for keyboard + * input events. + */ +class KeyboardListener +{ +public: + /** + * Callback for when a key is down (pressed). + * @param key the key that the event is for + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnKeyDown(KEYS key) = 0; + + /** + * Callback for when a key is up (released). + * @param key the key that the event is for + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnKeyUp(KEYS key) = 0; +}; + +#endif + diff --git a/src/framework/input/keysyms.h b/src/framework/input/keysyms.h new file mode 100644 index 0000000..8207152 --- /dev/null +++ b/src/framework/input/keysyms.h @@ -0,0 +1,237 @@ +#ifndef __FRAMEWORK_INPUT_KEYSYMS_H_INCLUDED__ +#define __FRAMEWORK_INPUT_KEYSYMS_H_INCLUDED__ + +#ifdef SDL + +#ifdef _MSC_VER +#include +#else +#include +#endif + +typedef enum KEYS { + KSYM_UNKNOWN = 0, + KSYM_ESCAPE = SDLK_ESCAPE, + KSYM_BACKSPACE = SDLK_BACKSPACE, + KSYM_END = SDLK_END, + KSYM_SOFT_LEFT = 0, + KSYM_SOFT_RIGHT = 0, + KSYM_HOME = SDLK_HOME, + KSYM_BACK = 0, + KSYM_CALL = 0, + KSYM_ENDCALL = 0, + KSYM_0 = SDLK_0, + KSYM_1 = SDLK_1, + KSYM_2 = SDLK_2, + KSYM_3 = SDLK_3, + KSYM_4 = SDLK_4, + KSYM_5 = SDLK_5, + KSYM_6 = SDLK_6, + KSYM_7 = SDLK_7, + KSYM_8 = SDLK_8, + KSYM_9 = SDLK_9, + KSYM_ASTERISK = SDLK_ASTERISK, + KSYM_HASH = SDLK_HASH, + KSYM_UP = SDLK_UP, + KSYM_DOWN = SDLK_DOWN, + KSYM_LEFT = SDLK_LEFT, + KSYM_RIGHT = SDLK_RIGHT, + KSYM_DPAD_CENTER = 0, + KSYM_VOLUME_UP = 0, + KSYM_VOLUME_DOWN = 0, + KSYM_CAMERA = 0, + KSYM_CLEAR = 0, + KSYM_A = SDLK_a, + KSYM_B = SDLK_b, + KSYM_C = SDLK_c, + KSYM_D = SDLK_d, + KSYM_E = SDLK_e, + KSYM_F = SDLK_f, + KSYM_G = SDLK_g, + KSYM_H = SDLK_h, + KSYM_I = SDLK_i, + KSYM_J = SDLK_j, + KSYM_K = SDLK_k, + KSYM_L = SDLK_l, + KSYM_M = SDLK_m, + KSYM_N = SDLK_n, + KSYM_O = SDLK_o, + KSYM_P = SDLK_p, + KSYM_Q = SDLK_q, + KSYM_R = SDLK_r, + KSYM_S = SDLK_s, + KSYM_T = SDLK_t, + KSYM_U = SDLK_u, + KSYM_V = SDLK_v, + KSYM_W = SDLK_w, + KSYM_X = SDLK_x, + KSYM_Y = SDLK_y, + KSYM_Z = SDLK_z, + KSYM_COMMA = SDLK_COMMA, + KSYM_PERIOD = SDLK_PERIOD, + KSYM_LALT = SDLK_LALT, + KSYM_RALT = SDLK_RALT, + KSYM_RCTRL = SDLK_RCTRL, + KSYM_LCTRL = SDLK_LCTRL, + KSYM_LSHIFT = SDLK_LSHIFT, + KSYM_RSHIFT = SDLK_RSHIFT, + KSYM_TAB = SDLK_TAB, + KSYM_SPACE = SDLK_SPACE, + KSYM_SYM = 0, + KSYM_RETURN = SDLK_RETURN, + KSYM_DELETE = SDLK_DELETE, + KSYM_MINUS = SDLK_MINUS, + KSYM_EQUALS = SDLK_EQUALS, + KSYM_LEFTBRACKET = SDLK_LEFTBRACKET, + KSYM_RIGHTBRACKET = SDLK_RIGHTBRACKET, + KSYM_BACKSLASH = SDLK_BACKSLASH, + KSYM_SEMICOLON = SDLK_SEMICOLON, + KSYM_QUOTE = SDLK_QUOTE, + KSYM_SLASH = SDLK_SLASH, + KSYM_AT = SDLK_AT, + KSYM_PLUS = SDLK_PLUS, + KSYM_MENU = 0, + KSYM_SEARCH = 0, + KSYM_PAGEUP = SDLK_PAGEUP, + KSYM_PAGEDOWN = SDLK_PAGEDOWN, + + // these are all set to correspond to the Xperia Play's physical gamepad + KSYM_BUTTON_A = 0, + KSYM_BUTTON_B = 0, + KSYM_BUTTON_C = 0, + KSYM_BUTTON_X = 0, + KSYM_BUTTON_Y = 0, + KSYM_BUTTON_Z = 0, + KSYM_BUTTON_L1 = 0, + KSYM_BUTTON_R1 = 0, + KSYM_BUTTON_L2 = 0, + KSYM_BUTTON_R2 = 0, + KSYM_BUTTON_THUMBL = 0, + KSYM_BUTTON_THUMBR = 0, + KSYM_BUTTON_START = 0, + KSYM_BUTTON_SELECT = 0, + KSYM_BUTTON_MODE = 0, + // --- + + KSYM_LAST = SDLK_LAST +} KEYS; + +#elif __S3E__ + +#include "s3eKeyboard.h" + +typedef enum KEYS +{ + KSYM_UNKNOWN = 0, + KSYM_ESCAPE = s3eKeyEsc, + KSYM_BACKSPACE = s3eKeyBackspace, + KSYM_END = s3eKeyKbEnd, + KSYM_SOFT_LEFT = s3eKeyLSK, + KSYM_SOFT_RIGHT = s3eKeyRSK, + KSYM_HOME = s3eKeyHomePage, + KSYM_BACK = s3eKeyBack, + KSYM_CALL = s3eKeyAccept, + KSYM_ENDCALL = s3eKeyEnd, + KSYM_0 = s3eKey0, + KSYM_1 = s3eKey1, + KSYM_2 = s3eKey2, + KSYM_3 = s3eKey3, + KSYM_4 = s3eKey4, + KSYM_5 = s3eKey5, + KSYM_6 = s3eKey6, + KSYM_7 = s3eKey7, + KSYM_8 = s3eKey8, + KSYM_9 = s3eKey9, + KSYM_ASTERISK = s3eKeyStar, + KSYM_HASH = s3eKeyHash, + KSYM_UP = s3eKeyUp, + KSYM_DOWN = s3eKeyDown, + KSYM_LEFT = s3eKeyLeft, + KSYM_RIGHT = s3eKeyRight, + KSYM_DPAD_CENTER = s3eKeyOk, + KSYM_VOLUME_UP = s3eKeyVolUp, + KSYM_VOLUME_DOWN = s3eKeyVolDown, + KSYM_CAMERA = s3eKeyCamera, + KSYM_CLEAR = s3eKeyCLR, + KSYM_A = s3eKeyA, + KSYM_B = s3eKeyB, + KSYM_C = s3eKeyC, + KSYM_D = s3eKeyD, + KSYM_E = s3eKeyE, + KSYM_F = s3eKeyF, + KSYM_G = s3eKeyG, + KSYM_H = s3eKeyH, + KSYM_I = s3eKeyI, + KSYM_J = s3eKeyJ, + KSYM_K = s3eKeyK, + KSYM_L = s3eKeyL, + KSYM_M = s3eKeyM, + KSYM_N = s3eKeyN, + KSYM_O = s3eKeyO, + KSYM_P = s3eKeyP, + KSYM_Q = s3eKeyQ, + KSYM_R = s3eKeyR, + KSYM_S = s3eKeyS, + KSYM_T = s3eKeyT, + KSYM_U = s3eKeyU, + KSYM_V = s3eKeyV, + KSYM_W = s3eKeyW, + KSYM_X = s3eKeyX, + KSYM_Y = s3eKeyY, + KSYM_Z = s3eKeyZ, + KSYM_COMMA = s3eKeyComma, + KSYM_PERIOD = s3eKeyPeriod, + KSYM_LALT = s3eKeyLeftAlt, + KSYM_RALT = s3eKeyRightAlt, + KSYM_RCTRL = s3eKeyRightControl, + KSYM_LCTRL = s3eKeyLeftControl, + KSYM_LSHIFT = s3eKeyLeftShift, + KSYM_RSHIFT = s3eKeyRightShift, + KSYM_TAB = s3eKeyTab, + KSYM_SPACE = s3eKeySpace, + KSYM_SYM = s3eKeySym, + KSYM_RETURN = s3eKeyEnter, + KSYM_DELETE = s3eKeyDelete, + KSYM_MINUS = s3eKeyMinus, + KSYM_EQUALS = s3eKeyEquals, + KSYM_LEFTBRACKET = s3eKeyLeftBracket, + KSYM_RIGHTBRACKET = s3eKeyRightBracket, + KSYM_BACKSLASH = s3eKeyBackSlash, + KSYM_SEMICOLON = s3eKeySemicolon, + KSYM_QUOTE = s3eKeyApostrophe, + KSYM_SLASH = s3eKeySlash, + KSYM_AT = s3eKeyAt, + KSYM_PLUS = s3eKeyNumPadPlus, + KSYM_MENU = s3eKeyMenu, + KSYM_SEARCH = s3eKeySearch, + KSYM_PAGEUP = s3eKeyPageUp, + KSYM_PAGEDOWN = s3eKeyPageDown, + + // these are all set to correspond to the Xperia Play's physical gamepad + KSYM_BUTTON_A = s3eKeyAbsGameA, //s3eKeyAbsOk, + KSYM_BUTTON_B = s3eKeyAbsGameB, //s3eKeyAbsBSK, + KSYM_BUTTON_C = 0, + KSYM_BUTTON_X = s3eKeyAbsGameD, + KSYM_BUTTON_Y = s3eKeyAbsGameC, + KSYM_BUTTON_Z = 0, + KSYM_BUTTON_L1 = s3eKeyLS, + KSYM_BUTTON_R1 = s3eKeyRS, + KSYM_BUTTON_L2 = 0, + KSYM_BUTTON_R2 = 0, + KSYM_BUTTON_THUMBL = 0, + KSYM_BUTTON_THUMBR = 0, + KSYM_BUTTON_START = s3eKeyRSK, + KSYM_BUTTON_SELECT = s3eKeyAbsASK, + KSYM_BUTTON_MODE = 0, + // --- + + KSYM_LAST = s3eKeyCount +} KEYS; + +#else + +#error Unknown platform + +#endif + +#endif diff --git a/src/framework/input/marmaladekeyboard.cpp b/src/framework/input/marmaladekeyboard.cpp new file mode 100644 index 0000000..e7e0c98 --- /dev/null +++ b/src/framework/input/marmaladekeyboard.cpp @@ -0,0 +1,105 @@ +#ifdef __S3E__ +#include "../debug.h" + +#include "marmaladekeyboard.h" +#include "keyboardlistener.h" +#include + +MarmaladeKeyboard::MarmaladeKeyboard(BOOL hasPhysicalKeysForGameControls) + : Keyboard() +{ + STACK_TRACE; + m_hasPhysicalKeysForGameControls = hasPhysicalKeysForGameControls; + + m_keys = new BOOL[KSYM_LAST]; + ASSERT(m_keys != NULL); + m_lockedKeys = new BOOL[KSYM_LAST]; + ASSERT(m_lockedKeys != NULL); + + Reset(); +} + +MarmaladeKeyboard::~MarmaladeKeyboard() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_keys); + SAFE_DELETE_ARRAY(m_lockedKeys); +} + +BOOL MarmaladeKeyboard::OnKeyEvent(const s3eKeyboardEvent *eventArgs) +{ + STACK_TRACE; + int32_t keyCode = (int32_t)eventArgs->m_Key; + BOOL isDown = (BOOL)eventArgs->m_Pressed; + + if (isDown) + { + m_keys[keyCode] = !(m_lockedKeys[keyCode]); // pressed only if not locked + + // always report keydown events + // NOTE: we're ignoring the "locked key" state because listeners + // don't have support for it (yet) + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnKeyDown((KEYS)keyCode)) + break; + } + } + else + { + // if the key is just being released this tick, then trigger an event in all listeners + if (m_keys[keyCode]) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnKeyUp((KEYS)keyCode)) + break; + } + } + + m_keys[keyCode] = FALSE; + m_lockedKeys[keyCode] = FALSE; + } + + return TRUE; +} + +BOOL MarmaladeKeyboard::OnKeyCharEvent(const s3eKeyboardCharEvent *eventArgs) +{ + STACK_TRACE; + // TODO: implementation + return FALSE; +} + +BOOL MarmaladeKeyboard::IsPressed(KEYS key) +{ + STACK_TRACE; + if (m_keys[key] && !m_lockedKeys[key]) + { + m_lockedKeys[key] = TRUE; + return TRUE; + } + else + return FALSE; +} + +void MarmaladeKeyboard::Reset() +{ + STACK_TRACE; + memset(m_keys, FALSE, sizeof(BOOL) * KSYM_LAST); + memset(m_lockedKeys, FALSE, sizeof(BOOL) * KSYM_LAST); +} + +void MarmaladeKeyboard::RegisterListener(KeyboardListener *listener) +{ + STACK_TRACE; + m_listeners.insert(listener); +} + +void MarmaladeKeyboard::UnregisterListener(KeyboardListener *listener) +{ + STACK_TRACE; + m_listeners.erase(listener); +} + +#endif diff --git a/src/framework/input/marmaladekeyboard.h b/src/framework/input/marmaladekeyboard.h new file mode 100644 index 0000000..1ef888b --- /dev/null +++ b/src/framework/input/marmaladekeyboard.h @@ -0,0 +1,40 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_INPUT_MARMALADEKEYBOARD_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MARMALADEKEYBOARD_H_INCLUDED__ + +#include "../common.h" +#include "keyboard.h" +#include "s3eKeyboard.h" +#include + +class KeyboardListener; + +class MarmaladeKeyboard : public Keyboard +{ +public: + MarmaladeKeyboard(BOOL hasPhysicalKeysForGameControls); + virtual ~MarmaladeKeyboard(); + + BOOL OnKeyEvent(const s3eKeyboardEvent *eventArgs); + BOOL OnKeyCharEvent(const s3eKeyboardCharEvent *eventArgs); + + BOOL HasPhysicalKeysForGameControls() const { return m_hasPhysicalKeysForGameControls; } + + BOOL IsDown(KEYS key) { return m_keys[key] && !m_lockedKeys[key]; } + BOOL IsPressed(KEYS key); + void Lock(KEYS key) { m_lockedKeys[key] = TRUE; } + + void Reset(); + + void RegisterListener(KeyboardListener *listener); + void UnregisterListener(KeyboardListener *listener); + +private: + stl::set m_listeners; + BOOL *m_keys; + BOOL *m_lockedKeys; + BOOL m_hasPhysicalKeysForGameControls; +}; + +#endif +#endif diff --git a/src/framework/input/marmalademouse.cpp b/src/framework/input/marmalademouse.cpp new file mode 100644 index 0000000..962acaf --- /dev/null +++ b/src/framework/input/marmalademouse.cpp @@ -0,0 +1,134 @@ +#ifdef __S3E__ +#include "../debug.h" + +#include "marmalademouse.h" +#include "mouselistener.h" +#include + +const int32_t NUM_BUTTONS = S3E_POINTER_BUTTON_MAX; + +MarmaladeMouse::MarmaladeMouse() + : Mouse() +{ + STACK_TRACE; + m_buttons = new BOOL[NUM_BUTTONS]; + ASSERT(m_buttons != NULL); + m_lockedButtons = new BOOL[NUM_BUTTONS]; + ASSERT(m_lockedButtons != NULL); + + Reset(); +} + +MarmaladeMouse::~MarmaladeMouse() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_buttons); + SAFE_DELETE_ARRAY(m_lockedButtons); +} + +void MarmaladeMouse::ResetDeltas() +{ + STACK_TRACE; + m_deltaX = 0; + m_deltaY = 0; +} + +BOOL MarmaladeMouse::OnButtonEvent(const s3ePointerEvent *eventArgs) +{ + STACK_TRACE; + int32_t button = (int32_t)eventArgs->m_Button; + BOOL isDown = (BOOL)eventArgs->m_Pressed; + int32_t x = eventArgs->m_x; + int32_t y = eventArgs->m_y; + + if (isDown) + { + // Pressed only if not locked + m_buttons[button] = !(m_lockedButtons[button]); + + // always report button down events + // NOTE: we're ignoring the "locked button" state because listeners + // don't have support for it (yet) + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseButtonDown((MOUSE_BUTTONS)button, (uint16_t)x, (uint16_t)y)) + break; + } + } + else + { + // if the button is just being released this tick, then trigger an event in all listeners + if (m_buttons[button]) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseButtonUp((MOUSE_BUTTONS)button, (uint16_t)x, (uint16_t)y)) + break; + } + } + + m_buttons[button] = FALSE; + m_lockedButtons[button] = FALSE; + } + + return TRUE; +} + +BOOL MarmaladeMouse::OnMotionEvent(const s3ePointerMotionEvent *eventArgs) +{ + STACK_TRACE; + m_deltaX = eventArgs->m_x - m_x; + m_deltaY = eventArgs->m_y - m_y; + + m_x = eventArgs->m_x; + m_y = eventArgs->m_y; + + // raise listener events for the mouse position only if it's moved this tick + if (m_deltaX != 0 || m_deltaY != 0) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseMove(m_x, m_y, m_deltaX, m_deltaY)) + break; + } + } + + return TRUE; +} + +BOOL MarmaladeMouse::IsPressed(MOUSE_BUTTONS button) +{ + STACK_TRACE; + if (m_buttons[button] && !m_lockedButtons[button]) + { + m_lockedButtons[button] = TRUE; + return TRUE; + } + else + return FALSE; +} + +void MarmaladeMouse::Reset() +{ + STACK_TRACE; + memset(m_buttons, FALSE, sizeof(BOOL) * NUM_BUTTONS); + memset(m_lockedButtons, FALSE, sizeof(BOOL) * NUM_BUTTONS); + m_x = 0; + m_y = 0; + m_deltaX = 0; + m_deltaY = 0; +} + +void MarmaladeMouse::RegisterListener(MouseListener *listener) +{ + STACK_TRACE; + m_listeners.insert(listener); +} + +void MarmaladeMouse::UnregisterListener(MouseListener *listener) +{ + STACK_TRACE; + m_listeners.erase(listener); +} + +#endif diff --git a/src/framework/input/marmalademouse.h b/src/framework/input/marmalademouse.h new file mode 100644 index 0000000..08df7eb --- /dev/null +++ b/src/framework/input/marmalademouse.h @@ -0,0 +1,49 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_INPUT_MARMALADEMOUSE_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MARMALADEMOUSE_H_INCLUDED__ + +#include "../common.h" +#include "mouse.h" +#include "s3ePointer.h" +#include + +class MouseListener; + +class MarmaladeMouse : public Mouse +{ +public: + MarmaladeMouse(); + virtual ~MarmaladeMouse(); + + void ResetDeltas(); + + BOOL OnButtonEvent(const s3ePointerEvent *eventArgs); + BOOL OnMotionEvent(const s3ePointerMotionEvent *eventArgs); + + BOOL IsDown(MOUSE_BUTTONS button) { return m_buttons[button] && !m_lockedButtons[button]; } + BOOL IsPressed(MOUSE_BUTTONS button); + void Lock(MOUSE_BUTTONS button) { m_lockedButtons[button] = TRUE; } + + uint16_t GetX() const { return m_x; } + uint16_t GetY() const { return m_y; } + int16_t GetDeltaX() const { return m_deltaX; } + int16_t GetDeltaY() const { return m_deltaY; } + + void Reset(); + + void RegisterListener(MouseListener *listener); + void UnregisterListener(MouseListener *listener); + +private: + stl::set m_listeners; + BOOL *m_buttons; + BOOL *m_lockedButtons; + + uint16_t m_x; + uint16_t m_y; + int16_t m_deltaX; + int16_t m_deltaY; +}; + +#endif +#endif diff --git a/src/framework/input/marmaladetouchscreen.cpp b/src/framework/input/marmaladetouchscreen.cpp new file mode 100644 index 0000000..aa2eae1 --- /dev/null +++ b/src/framework/input/marmaladetouchscreen.cpp @@ -0,0 +1,386 @@ +#ifdef __S3E__ +#include "../debug.h" +#include "../log.h" + +#include "marmaladetouchscreen.h" +#include "touchscreenlistener.h" +#include "../math/circle.h" +#include "../math/mathhelpers.h" + +MarmaladeTouchPointer::MarmaladeTouchPointer() +{ + STACK_TRACE; + m_id = INVALID_TOUCH_POINTER; + m_x = 0; + m_y = 0; + m_deltaX = 0; + m_deltaY = 0; + m_isTouching = FALSE; +} + +MarmaladeTouchPointer::~MarmaladeTouchPointer() +{ + STACK_TRACE; +} + +void MarmaladeTouchPointer::ResetDeltas() +{ + STACK_TRACE; + m_deltaX = 0; + m_deltaY = 0; +} + +BOOL MarmaladeTouchPointer::IsTouchingWithinArea(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) const +{ + STACK_TRACE; + if (m_isTouching && m_x >= left && m_y >= top && m_x <= right && m_y <= bottom) + return TRUE; + else + return FALSE; +} + +BOOL MarmaladeTouchPointer::IsTouchingWithinArea(const Rect &area) const +{ + STACK_TRACE; + if (m_isTouching && m_x >= area.left && m_y >= area.top && m_x <= area.right && m_y <= area.bottom) + return TRUE; + else + return FALSE; +} + +BOOL MarmaladeTouchPointer::IsTouchingWithinArea(uint16_t centerX, uint16_t centerY, uint16_t radius) const +{ + STACK_TRACE; + if (m_isTouching) + { + uint32_t squaredDistance = ((centerX - m_x) * (centerX - m_x)) + ((centerY - m_y) * (centerY - m_y)); + uint32_t squaredRadius = radius * radius; + if (squaredDistance <= squaredRadius) + return TRUE; + } + + return FALSE; +} + +BOOL MarmaladeTouchPointer::IsTouchingWithinArea(const Circle &area) const +{ + STACK_TRACE; + if (m_isTouching) + { + uint32_t squaredDistance = ((area.x - m_x) * (area.x - m_x)) + ((area.y - m_y) * (area.y - m_y)); + uint32_t squaredRadius = area.radius * area.radius; + if (squaredDistance <= squaredRadius) + return TRUE; + } + + return FALSE; +} + +void MarmaladeTouchPointer::OnDown(int32_t id, uint16_t x, uint16_t y) +{ + STACK_TRACE; + m_isTouching = TRUE; + m_x = x; + m_y = y; + m_deltaX = 0; + m_deltaY = 0; + m_id = id; +} + +void MarmaladeTouchPointer::OnMove(int32_t id, uint16_t x, uint16_t y) +{ + STACK_TRACE; + // calculate the amount moved since the last time first... + m_deltaX = x - m_x; + m_deltaY = y - m_y; + + // ... now we can set the new position + m_x = x; + m_y = y; +} + +void MarmaladeTouchPointer::OnUp() +{ + STACK_TRACE; + m_id = INVALID_TOUCH_POINTER; + m_x = 0; + m_y = 0; + m_deltaX = 0; + m_deltaY = 0; + m_isTouching = FALSE; +} + +MarmaladeTouchscreen::MarmaladeTouchscreen(MarmaladeSystem *system, BOOL isMultitouchAvailable) +{ + STACK_TRACE; + m_system = system; + + m_isMultitouchAvailable = isMultitouchAvailable; + if (m_isMultitouchAvailable) + m_maxTouchPoints = S3E_POINTER_TOUCH_MAX; + else + m_maxTouchPoints = 1; + + m_pointers = new MarmaladeTouchPointer[m_maxTouchPoints]; + ASSERT(m_pointers != NULL); + + Reset(); +} + +MarmaladeTouchscreen::~MarmaladeTouchscreen() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_pointers); +} + +void MarmaladeTouchscreen::ResetDeltas() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + if (m_pointers[i].GetId() != INVALID_TOUCH_POINTER) + m_pointers[i].ResetDeltas(); + } +} + +void MarmaladeTouchscreen::ResetViewBounds(const Rect &viewBounds) +{ + STACK_TRACE; + m_viewBounds = viewBounds; +} + +BOOL MarmaladeTouchscreen::OnSingleTouchTapEvent(const s3ePointerEvent *eventArgs) +{ + STACK_TRACE; + ASSERT(m_maxTouchPoints == 1); + return FALSE; +} + +BOOL MarmaladeTouchscreen::OnSingleTouchMotionEvent(const s3ePointerMotionEvent *eventArgs) +{ + STACK_TRACE; + ASSERT(m_maxTouchPoints == 1); + return FALSE; +} + +BOOL MarmaladeTouchscreen::OnMultiTouchTapEvent(const s3ePointerTouchEvent *eventArgs) +{ + STACK_TRACE; + ASSERT(m_maxTouchPoints > 1); + BOOL isDown = (BOOL)eventArgs->m_Pressed; + if (isDown) + { + // this should only happen for new touch points? + MarmaladeTouchPointer *pointer = GetPointerByIdOrFirstAvailable(eventArgs->m_TouchID); + if (pointer->GetId() == INVALID_TOUCH_POINTER) + { + uint16_t x = Clamp(eventArgs->m_x, m_viewBounds.left, m_viewBounds.right) - m_viewBounds.left; + uint16_t y = Clamp(eventArgs->m_y, m_viewBounds.top, m_viewBounds.bottom) - m_viewBounds.top; + pointer->OnDown(eventArgs->m_TouchID, x, y); + + // if no other touch points are currently down, then this one is to be + // considered the primary one + BOOL isPrimary = FALSE; + if (m_currentTouchPoints == 0) + { + m_primaryPointer = pointer; + isPrimary = TRUE; + } + + ++m_currentTouchPoints; + + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnTouchDown(pointer->GetId(), pointer->GetX(), pointer->GetY(), isPrimary)) + break; + } + } + else + { + LOG_WARN("TOUCHSCREEN", "Received s3ePointerTouchEvent, m_Pressed=1 for m_TouchID=%d which is already in m_pointers.\n", eventArgs->m_TouchID); + } + } + else + { + // this should only happen for existing touch points? + MarmaladeTouchPointer *pointer = GetPointerById_internal(eventArgs->m_TouchID); + if (pointer != NULL) + { + pointer->OnUp(); + + // if this pointer was the primary one, we need to switch the primary + // to one of the other currently down pointers + BOOL wasPrimary = FALSE; + if (m_primaryPointer == pointer) + { + m_primaryPointer = GetNextDownPointer(); + wasPrimary = TRUE; + } + + --m_currentTouchPoints; + + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnTouchUp(eventArgs->m_TouchID, wasPrimary)) + break; + } + } + else + { + // Not sure what to do here? this does seem to happen sometimes, at + // least when using the simulator + LOG_WARN("TOUCHSCREEN", "Received s3ePointerTouchEvent, m_Pressed=0 for m_TouchID=%d which is not currently in m_pointers.\n", eventArgs->m_TouchID); + } + } + + return TRUE; +} + +BOOL MarmaladeTouchscreen::OnMultiTouchMotionEvent(const s3ePointerTouchMotionEvent *eventArgs) +{ + STACK_TRACE; + ASSERT(m_maxTouchPoints > 1); + MarmaladeTouchPointer *pointer = GetPointerById_internal(eventArgs->m_TouchID); + if (pointer != NULL) + { + uint16_t x = Clamp(eventArgs->m_x, m_viewBounds.left, m_viewBounds.right) - m_viewBounds.left; + uint16_t y = Clamp(eventArgs->m_y, m_viewBounds.top, m_viewBounds.bottom) - m_viewBounds.top; + pointer->OnMove(eventArgs->m_TouchID, x, y); + + BOOL isPrimary = FALSE; + if (m_primaryPointer == pointer) + isPrimary = TRUE; + + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnTouchMove(pointer->GetId(), pointer->GetX(), pointer->GetY(), pointer->GetDeltaX(), pointer->GetDeltaY(), isPrimary)) + break; + } + } + else + { + // Not sure what to do here? this does seem to happen sometimes, at + // least when using the simulator + LOG_WARN("TOUCHSCREEN", "Received s3ePointerTouchMotionEvent, m_TouchID=%d which is not currently in m_pointers.\n", eventArgs->m_TouchID); + } + + return TRUE; +} + +BOOL MarmaladeTouchscreen::WasTapped() +{ + STACK_TRACE; + if (m_isTouching && !m_isLocked) + { + m_isLocked = TRUE; + } + else if (!m_isTouching && m_isLocked) + { + m_isLocked = FALSE; + return TRUE; + } + + return FALSE; +} + +const TouchPointer* MarmaladeTouchscreen::GetPointerById(int32_t id) const +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + if (m_pointers[i].GetId() == id) + return (TouchPointer*)&m_pointers[i]; + } + + return NULL; +} + +MarmaladeTouchPointer* MarmaladeTouchscreen::GetPointerById_internal(int32_t id) +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + if (m_pointers[i].GetId() == id) + return &m_pointers[i]; + } + + return NULL; +} + +MarmaladeTouchPointer* MarmaladeTouchscreen::GetFirstAvailablePointer() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + if (m_pointers[i].GetId() == INVALID_TOUCH_POINTER) + return &m_pointers[i]; + } + + return NULL; +} + +MarmaladeTouchPointer* MarmaladeTouchscreen::GetPointerByIdOrFirstAvailable(int32_t id) +{ + STACK_TRACE; + MarmaladeTouchPointer *result = GetPointerById_internal(id); + if (result == NULL) + result = GetFirstAvailablePointer(); + + return result; +} + +MarmaladeTouchPointer* MarmaladeTouchscreen::GetNextDownPointer() +{ + STACK_TRACE; + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + if (m_pointers[i].IsTouching()) + return &m_pointers[i]; + } + + // default to the first pointer. we don't want the primary pointer to + // ever be NULL. it is up to the calling code to check the primary + // pointer's IsTouching() state + return &m_pointers[0]; +} + +void MarmaladeTouchscreen::Reset() +{ + STACK_TRACE; + MarmaladeTouchPointer *oldPrimaryPointer = m_primaryPointer; + + m_primaryPointer = &m_pointers[0]; + m_isTouching = FALSE; + m_isLocked = FALSE; + m_currentTouchPoints = 0; + + for (uint32_t i = 0; i < m_maxTouchPoints; ++i) + { + BOOL isPrimary = FALSE; + if (oldPrimaryPointer == &m_pointers[i]) + isPrimary = TRUE; + uint32_t id = m_pointers[i].GetId(); + + m_pointers[i].OnUp(); + + for (stl::set::iterator j = m_listeners.begin(); j != m_listeners.end(); ++j) + { + if ((*j)->OnTouchUp(id, isPrimary)) + break; + } + } +} + +void MarmaladeTouchscreen::RegisterListener(TouchscreenListener *listener) +{ + STACK_TRACE; + m_listeners.insert(listener); +} + +void MarmaladeTouchscreen::UnregisterListener(TouchscreenListener *listener) +{ + STACK_TRACE; + m_listeners.erase(listener); +} + +#endif diff --git a/src/framework/input/marmaladetouchscreen.h b/src/framework/input/marmaladetouchscreen.h new file mode 100644 index 0000000..d1f9d6e --- /dev/null +++ b/src/framework/input/marmaladetouchscreen.h @@ -0,0 +1,97 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_INPUT_MARMALADETOUCHSCREEN_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MARMALADETOUCHSCREEN_H_INCLUDED__ + +#include "../common.h" +#include "touchscreen.h" +#include "../math/rect.h" +#include "s3ePointer.h" +#include + +class MarmaladeSystem; +class TouchscreenListener; +struct Circle; + +class MarmaladeTouchPointer : public TouchPointer +{ +public: + MarmaladeTouchPointer(); + virtual ~MarmaladeTouchPointer(); + + void ResetDeltas(); + + int32_t GetId() const { return m_id; } + uint16_t GetX() const { return m_x; } + uint16_t GetY() const { return m_y; } + int16_t GetDeltaX() const { return m_deltaX; } + int16_t GetDeltaY() const { return m_deltaY; } + BOOL IsTouching() const { return m_isTouching; } + + BOOL IsTouchingWithinArea(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) const; + BOOL IsTouchingWithinArea(const Rect &area) const; + BOOL IsTouchingWithinArea(uint16_t centerX, uint16_t centerY, uint16_t radius) const; + BOOL IsTouchingWithinArea(const Circle &area) const; + + void OnDown(int32_t id, uint16_t x, uint16_t y); + void OnMove(int32_t id, uint16_t x, uint16_t y); + void OnUp(); + +private: + int32_t m_id; + uint16_t m_x; + uint16_t m_y; + int16_t m_deltaX; + int16_t m_deltaY; + BOOL m_isTouching; +}; + +class MarmaladeTouchscreen : public Touchscreen +{ +public: + MarmaladeTouchscreen(MarmaladeSystem *system, BOOL isMultitouchAvailable); + virtual ~MarmaladeTouchscreen(); + + void ResetDeltas(); + void ResetViewBounds(const Rect &viewBounds); + + BOOL OnSingleTouchTapEvent(const s3ePointerEvent *eventArgs); + BOOL OnSingleTouchMotionEvent(const s3ePointerMotionEvent *eventArgs); + BOOL OnMultiTouchTapEvent(const s3ePointerTouchEvent *eventArgs); + BOOL OnMultiTouchMotionEvent(const s3ePointerTouchMotionEvent *eventArgs); + + BOOL IsMultitouchAvailable() const { return m_isMultitouchAvailable; } + uint32_t GetPointerCount() const { return m_maxTouchPoints; } + uint32_t GetCurrentPointerCount() const { return m_currentTouchPoints; } + BOOL IsTouching() const { return m_isTouching; } + BOOL WasTapped(); + const TouchPointer* GetPrimaryPointer() const { return (TouchPointer*)m_primaryPointer; } + const TouchPointer* GetPointer(uint32_t index) const { return (TouchPointer*)&m_pointers[index]; } + const TouchPointer* GetPointerById(int32_t id) const; + + void Reset(); + + void RegisterListener(TouchscreenListener *listener); + void UnregisterListener(TouchscreenListener *listener); + +private: + MarmaladeTouchPointer* GetPointerById_internal(int32_t id); + + MarmaladeTouchPointer* GetFirstAvailablePointer(); + MarmaladeTouchPointer* GetPointerByIdOrFirstAvailable(int32_t id); + MarmaladeTouchPointer* GetNextDownPointer(); + + Rect m_viewBounds; + stl::set m_listeners; + MarmaladeTouchPointer *m_pointers; + MarmaladeTouchPointer *m_primaryPointer; + BOOL m_isTouching; + BOOL m_isLocked; + + MarmaladeSystem *m_system; + BOOL m_isMultitouchAvailable; + uint32_t m_maxTouchPoints; + uint32_t m_currentTouchPoints; +}; + +#endif +#endif diff --git a/src/framework/input/mouse.h b/src/framework/input/mouse.h new file mode 100644 index 0000000..bbc50db --- /dev/null +++ b/src/framework/input/mouse.h @@ -0,0 +1,82 @@ +#ifndef __FRAMEWORK_INPUT_MOUSE_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MOUSE_H_INCLUDED__ + +#include "../common.h" +#include "mousebuttons.h" + +class MouseListener; + +/** + * Interface for a mouse input device class. + */ +class Mouse +{ +public: + Mouse() {} + virtual ~Mouse() {} + + /** + * Checks if the button is currently down, but not locked. + * @param button the button to check + * @return TRUE if down and not locked, FALSE if not down or locked + */ + virtual BOOL IsDown(MOUSE_BUTTONS button) = 0; + + /** + * Checks if the button is currently down, but not locked. If so, the + * button is locked until released so that duplicate "down" events will + * not be registered for this button until it is released and pressed + * down again. + * @param button the button to check + * @return TRUE if down and not locked, FALSE if not down or locked + */ + virtual BOOL IsPressed(MOUSE_BUTTONS button) = 0; + + /** + * Locks the button so that it will not be reported as down until it is + * released and then pressed down again. + * @param button the button to lock + */ + virtual void Lock(MOUSE_BUTTONS button) = 0; + + /** + * @return current X coordinate of the mouse cursor + */ + virtual uint16_t GetX() const = 0; + + /** + * @return current Y coordinate of the mouse cursor + */ + virtual uint16_t GetY() const = 0; + + /** + * @return amount the mouse cursor moved since the last update along the X axis + */ + virtual int16_t GetDeltaX() const = 0; + + /** + * @return amount the mouse cursor moved since the last update along the Y axis + */ + virtual int16_t GetDeltaY() const = 0; + + /** + * Resets the current mouse coordinates, button states and locked button states. + */ + virtual void Reset() = 0; + + /** + * Registers a mouse event listener so that mouse events will be + * sent to it. + * @param listener the listener object to register + */ + virtual void RegisterListener(MouseListener *listener) = 0; + + /** + * Unregisters a mouse event listener so that mouse events will no + * longer be sent to it. + * @param listener the listener object to unregister + */ + virtual void UnregisterListener(MouseListener *listener) = 0; +}; + +#endif diff --git a/src/framework/input/mousebuttons.h b/src/framework/input/mousebuttons.h new file mode 100644 index 0000000..d99f3da --- /dev/null +++ b/src/framework/input/mousebuttons.h @@ -0,0 +1,14 @@ +#ifndef __FRAMEWORK_INPUT_MOUSEBUTTONS_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MOUSEBUTTONS_H_INCLUDED__ + +enum MOUSE_BUTTONS +{ + MOUSE_LEFT = 0, + MOUSE_MIDDLE = 1, + MOUSE_RIGHT = 2, + MOUSE_WHEEL_UP = 3, + MOUSE_WHEEL_DOWN = 4 +}; + +#endif + diff --git a/src/framework/input/mouselistener.h b/src/framework/input/mouselistener.h new file mode 100644 index 0000000..8da3d7d --- /dev/null +++ b/src/framework/input/mouselistener.h @@ -0,0 +1,47 @@ +#ifndef __FRAMEWORK_INPUT_MOUSELISTENER_H_INCLUDED__ +#define __FRAMEWORK_INPUT_MOUSELISTENER_H_INCLUDED__ + +#include "../common.h" +#include "mousebuttons.h" + +/** + * Interface for objects that want to receive callbacks for mouse + * input events. + */ +class MouseListener +{ +public: + /** + * Callback for when a button is down (pressed). + * @param button the button that the event is for + * @param x current X coordinate of the mouse cursor + * @param y current Y coordinate of the mouse cursor + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnMouseButtonDown(MOUSE_BUTTONS button, uint16_t x, uint16_t y) = 0; + + /** + * Callback for when a button is up (released). + * @param button the button that the event is for + * @param x current X coordinate of the mouse cursor + * @param y current Y coordinate of the mouse cursor + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnMouseButtonUp(MOUSE_BUTTONS button, uint16_t x, uint16_t y) = 0; + + /** + * Callback for when the mouse cursor moves. + * @param x new X coordinate of the mouse cursor + * @param y new Y coordinate of the mouse cursor + * @param deltaX amount the mouse cursor moved since the last move event along the X axis + * @param deltaY amount the mouse cursor moved since the last move event along the Y axis + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnMouseMove(uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY) = 0; +}; + +#endif + diff --git a/src/framework/input/sdlkeyboard.cpp b/src/framework/input/sdlkeyboard.cpp new file mode 100644 index 0000000..303f5a5 --- /dev/null +++ b/src/framework/input/sdlkeyboard.cpp @@ -0,0 +1,98 @@ +#ifdef SDL +#include "../debug.h" + +#include "sdlkeyboard.h" +#include "keyboardlistener.h" +#include "../sdlincludes.h" +#include "../sdlsystem.h" +#include + +SDLKeyboard::SDLKeyboard(SDLSystem *system, BOOL hasPhysicalKeysForGameControls) +{ + STACK_TRACE; + m_system = system; + m_hasPhysicalKeysForGameControls = hasPhysicalKeysForGameControls; + + m_keys = new BOOL[KSYM_LAST]; + ASSERT(m_keys != NULL); + m_lockedKeys = new BOOL[KSYM_LAST]; + ASSERT(m_lockedKeys != NULL); + + Reset(); +} + +SDLKeyboard::~SDLKeyboard() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_keys); + SAFE_DELETE_ARRAY(m_lockedKeys); +} + +BOOL SDLKeyboard::OnKeyEvent(const SDL_KeyboardEvent *eventArgs) +{ + STACK_TRACE; + int32_t keyCode = (int32_t)eventArgs->keysym.sym; + + if (eventArgs->state == SDL_PRESSED) + { + m_keys[keyCode] = !(m_lockedKeys[keyCode]); // pressed only if not locked + + // always report keydown events + // NOTE: we're ignoring the "locked key" state because listeners + // don't have support for it (yet) + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnKeyDown((KEYS)keyCode)) + break; + } + } + else + { + // if the key is just being released this tick, then trigger an event in all listeners + if (m_keys[keyCode]) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnKeyUp((KEYS)keyCode)) + break; + } + } + + m_keys[keyCode] = FALSE; + m_lockedKeys[keyCode] = FALSE; + } + + return TRUE; +} + +BOOL SDLKeyboard::IsPressed(KEYS key) +{ + STACK_TRACE; + if (m_keys[key] && !m_lockedKeys[key]) + { + m_lockedKeys[key] = TRUE; + return TRUE; + } + else + return FALSE; +} + +void SDLKeyboard::Reset() +{ + STACK_TRACE; + memset(m_keys, FALSE, sizeof(BOOL) * KSYM_LAST); + memset(m_lockedKeys, FALSE, sizeof(BOOL) * KSYM_LAST); +} + +void SDLKeyboard::RegisterListener(KeyboardListener *listener) +{ + m_listeners.insert(listener); +} + +void SDLKeyboard::UnregisterListener(KeyboardListener *listener) +{ + m_listeners.erase(listener); +} + +#endif + diff --git a/src/framework/input/sdlkeyboard.h b/src/framework/input/sdlkeyboard.h new file mode 100644 index 0000000..c133ea1 --- /dev/null +++ b/src/framework/input/sdlkeyboard.h @@ -0,0 +1,43 @@ +#ifdef SDL +#ifndef __FRAMEWORK_INPUT_SDLKEYBOARD_H_INCLUDED__ +#define __FRAMEWORK_INPUT_SDLKEYBOARD_H_INCLUDED__ + +#include "../common.h" +#include "keyboard.h" +#include "../sdlincludes.h" +#include + +class KeyboardListener; +class SDLSystem; + +class SDLKeyboard : public Keyboard +{ +public: + SDLKeyboard(SDLSystem *system, BOOL hasPhysicalKeysForGameControls); + virtual ~SDLKeyboard(); + + BOOL OnKeyEvent(const SDL_KeyboardEvent *eventArgs); + + BOOL HasPhysicalKeysForGameControls() const { return m_hasPhysicalKeysForGameControls; } + + BOOL IsDown(KEYS key) { return m_keys[key] && !m_lockedKeys[key]; } + BOOL IsPressed(KEYS key); + void Lock(KEYS key) { m_lockedKeys[key] = TRUE; } + + void Reset(); + + void RegisterListener(KeyboardListener *listener); + void UnregisterListener(KeyboardListener *listener); + +private: + stl::set m_listeners; + SDLSystem *m_system; + + BOOL *m_keys; + BOOL *m_lockedKeys; + BOOL m_hasPhysicalKeysForGameControls; +}; + +#endif +#endif + diff --git a/src/framework/input/sdlmouse.cpp b/src/framework/input/sdlmouse.cpp new file mode 100644 index 0000000..1500c25 --- /dev/null +++ b/src/framework/input/sdlmouse.cpp @@ -0,0 +1,141 @@ +#ifdef SDL +#include "../debug.h" + +#include "sdlmouse.h" +#include "mouselistener.h" +#include "../sdlincludes.h" +#include "../sdlsystem.h" +#include + +// TODO: query hardware for number of buttons? +const int32_t NUM_BUTTONS = 5; + +SDLMouse::SDLMouse(SDLSystem *system) +{ + STACK_TRACE; + m_system = system; + + m_buttons = new BOOL[NUM_BUTTONS]; + ASSERT(m_buttons != NULL); + m_lockedButtons = new BOOL[NUM_BUTTONS]; + ASSERT(m_lockedButtons != NULL); + + Reset(); +} + +SDLMouse::~SDLMouse() +{ + STACK_TRACE; + SAFE_DELETE_ARRAY(m_buttons); + SAFE_DELETE_ARRAY(m_lockedButtons); +} + +void SDLMouse::ResetDeltas() +{ + STACK_TRACE; + m_deltaX = 0; + m_deltaY = 0; +} + +BOOL SDLMouse::OnButtonEvent(const SDL_MouseButtonEvent *eventArgs) +{ + STACK_TRACE; + // translate from SDL's button values to our own MOUSE_BUTTONS enum + int32_t button = (int32_t)eventArgs->button - 1; + + if (eventArgs->state == SDL_PRESSED) + { + // Pressed only if not locked + m_buttons[button] = !(m_lockedButtons[button]); + + uint16_t x = eventArgs->x; + uint16_t y = eventArgs->y; + + // always report button down events + // NOTE: we're ignoring the "locked button" state because listeners + // don't have support for it (yet) + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseButtonDown((MOUSE_BUTTONS)button, x, y)) + break; + } + } + else + { + uint16_t x = eventArgs->x; + uint16_t y = eventArgs->y; + + // if the button is just being released this tick, then trigger an event in all listeners + if (m_buttons[button]) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseButtonUp((MOUSE_BUTTONS)button, x, y)) + break; + } + } + + m_buttons[button] = FALSE; + m_lockedButtons[button] = FALSE; + } + + return TRUE; +} + +BOOL SDLMouse::OnMotionEvent(const SDL_MouseMotionEvent *eventArgs) +{ + STACK_TRACE; + m_deltaX = eventArgs->x - m_x; + m_deltaY = eventArgs->y - m_y; + + m_x = eventArgs->x; + m_y = eventArgs->y; + + // raise listener events for the mouse position only if it's moved this tick + if (m_deltaX != 0 || m_deltaY != 0) + { + for (stl::set::iterator i = m_listeners.begin(); i != m_listeners.end(); ++i) + { + if ((*i)->OnMouseMove(m_x, m_y, m_deltaX, m_deltaY)) + break; + } + } + + return TRUE; +} + +BOOL SDLMouse::IsPressed(MOUSE_BUTTONS button) +{ + STACK_TRACE; + if (m_buttons[button] && !m_lockedButtons[button]) + { + m_lockedButtons[button] = TRUE; + return TRUE; + } + else + return FALSE; +} + +void SDLMouse::Reset() +{ + STACK_TRACE; + memset(m_buttons, FALSE, sizeof(BOOL) * NUM_BUTTONS); + memset(m_lockedButtons, FALSE, sizeof(BOOL) * NUM_BUTTONS); + m_x = 0; + m_y = 0; + m_deltaX = 0; + m_deltaY = 0; +} + +void SDLMouse::RegisterListener(MouseListener *listener) +{ + m_listeners.insert(listener); +} + +void SDLMouse::UnregisterListener(MouseListener *listener) +{ + m_listeners.erase(listener); +} + +#endif + diff --git a/src/framework/input/sdlmouse.h b/src/framework/input/sdlmouse.h new file mode 100644 index 0000000..440466a --- /dev/null +++ b/src/framework/input/sdlmouse.h @@ -0,0 +1,53 @@ +#ifdef SDL +#ifndef __FRAMEWORK_INPUT_SDLMOUSE_H_INCLUDED__ +#define __FRAMEWORK_INPUT_SDLMOUSE_H_INCLUDED__ + +#include "../common.h" +#include "mouse.h" +#include "../sdlincludes.h" +#include + +class MouseListener; +class SDLSystem; + +class SDLMouse : public Mouse +{ +public: + SDLMouse(SDLSystem *system); + virtual ~SDLMouse(); + + void ResetDeltas(); + + BOOL OnButtonEvent(const SDL_MouseButtonEvent *eventArgs); + BOOL OnMotionEvent(const SDL_MouseMotionEvent *eventArgs); + + BOOL IsDown(MOUSE_BUTTONS button) { return m_buttons[button] && !m_lockedButtons[button]; } + BOOL IsPressed(MOUSE_BUTTONS button); + void Lock(MOUSE_BUTTONS button) { m_lockedButtons[button] = TRUE; } + + uint16_t GetX() const { return m_x; } + uint16_t GetY() const { return m_y; } + int16_t GetDeltaX() const { return m_deltaX; } + int16_t GetDeltaY() const { return m_deltaY; } + + void Reset(); + + void RegisterListener(MouseListener *listener); + void UnregisterListener(MouseListener *listener); + +private: + stl::set m_listeners; + SDLSystem *m_system; + + BOOL *m_buttons; + BOOL *m_lockedButtons; + + uint16_t m_x; + uint16_t m_y; + int16_t m_deltaX; + int16_t m_deltaY; +}; + +#endif +#endif + diff --git a/src/framework/input/touchscreen.h b/src/framework/input/touchscreen.h new file mode 100644 index 0000000..0888226 --- /dev/null +++ b/src/framework/input/touchscreen.h @@ -0,0 +1,163 @@ +#ifndef __FRAMEWORK_INPUT_TOUCHSCREEN_H_INCLUDED__ +#define __FRAMEWORK_INPUT_TOUCHSCREEN_H_INCLUDED__ + +#include "../common.h" + +class TouchscreenListener; +struct Rect; +struct Circle; + +const int32_t INVALID_TOUCH_POINTER = -1; + +/** + * Interface for a touch point class associated with a touch screen input device. + */ +class TouchPointer +{ +public: + TouchPointer() {} + virtual ~TouchPointer() {} + + /** + * @return a unique ID that can be used to refer to this touch point + * regardless of what order it is in in the list of touch + * points maintained by the touch screen device + */ + virtual int32_t GetId() const = 0; + + /** + * @return current X coordinate of the touch point + */ + virtual uint16_t GetX() const = 0; + + /** + * @return current Y coordinate of the touch point + */ + virtual uint16_t GetY() const = 0; + + /** + * @return amount the touch point moved since the last update along the X axis + */ + virtual int16_t GetDeltaX() const = 0; + + /** + * @return amount the touch point moved since the last update along the Y axis + */ + virtual int16_t GetDeltaY() const = 0; + + /** + * @return TRUE if this touch point is currently down + */ + virtual BOOL IsTouching() const = 0; + + /** + * Checks if this touch point is currently down within a given area. + * @param left left X coordinate of the area to check + * @param top top Y coordinate of the area to check + * @param right right X coordinate of the area to check + * @param bottom bottom Y coordinate of the area to check + * @return TRUE if the touch point is currently down within the given area + */ + virtual BOOL IsTouchingWithinArea(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) const = 0; + + /** + * Checks if this touch point is currently down within a given area. + * @param area the area to check + * @return TRUE if the touch point is currently down within the given area + */ + virtual BOOL IsTouchingWithinArea(const Rect &area) const = 0; + + /** + * Checks if this touch point is currently down within a given area. + * @param centerX X coordinate of the center of a circular area to check + * @param centerY Y coordinate of the center of a circular area to check + * @param radius the radius of the circular area to check + * @return TRUE if the touch point is currently down within the given area + */ + virtual BOOL IsTouchingWithinArea(uint16_t centerX, uint16_t centerY, uint16_t radius) const = 0; + + /** + * Checks if this touch point is currently down within a given area. + * @param area the area to check + * @return TRUE if the touch point is currently down within the given area + */ + virtual BOOL IsTouchingWithinArea(const Circle &area) const = 0; +}; + +/** + * Interface for a touch screen input device class. + */ +class Touchscreen +{ +public: + Touchscreen() {} + virtual ~Touchscreen() {} + + /** + * @return TRUE if multitouch support was detected in the touch screen input device + */ + virtual BOOL IsMultitouchAvailable() const = 0; + + /** + * @return the maximum number of touch points supported (not necessarily the number currently down) + */ + virtual uint32_t GetPointerCount() const = 0; + + /** + * @return TRUE if at least one touch point is currently down + */ + virtual BOOL IsTouching() const = 0; + + /** + * Determines if the touch screen was tapped during the last tick, but not + * the tick before that (in other words, was just initially tapped). + * @return TRUE if the touch screen was just tapped in the last tick + */ + virtual BOOL WasTapped() = 0; + + /** + * @return the primary touch pointer (the first one down or the only one + * down). This will never be NULL, but it may refer to a touch + * point whose IsTouching returns FALSE. + */ + virtual const TouchPointer* GetPrimaryPointer() const = 0; + + /** + * Gets a touch pointer by it's array index. The exact pointer returned + * may vary between calls as other touch points go down or are released. + * @param index the index of the touch pointer to get. Should be in the + * range 0 .. (GetPointerCount() - 1) + * @return the corresponding touch pointer + */ + virtual const TouchPointer* GetPointer(uint32_t index) const = 0; + + /** + * Gets a touch pointer by it's unique ID. This will always return the + * same pointer between calls as long as it's being held down. + * @param id the unique ID of the pointer to get + * @return the corresponding touch pointer, or NULL if the ID doesn't match any existing touch pointer + */ + virtual const TouchPointer* GetPointerById(int32_t id) const = 0; + + /** + * Resets the current touch screen and all touch point states. + */ + virtual void Reset() = 0; + + /** + * Registers a touch screen event listener so that touch events will be + * sent to it. + * @param listener the listener object to register + */ + virtual void RegisterListener(TouchscreenListener *listener) = 0; + + /** + * Unregisters a touch screen event listener so that touch events will no + * longer be sent to it. + * @param listener the listener object to unregister + */ + virtual void UnregisterListener(TouchscreenListener *listener) = 0; +}; + +#endif + diff --git a/src/framework/input/touchscreenlistener.h b/src/framework/input/touchscreenlistener.h new file mode 100644 index 0000000..0f85b83 --- /dev/null +++ b/src/framework/input/touchscreenlistener.h @@ -0,0 +1,51 @@ +#ifndef __FRAMEWORK_INPUT_TOUCHSCREENLISTENER_H_INCLUDED__ +#define __FRAMEWORK_INPUT_TOUCHSCREENLISTENER_H_INCLUDED__ + +#include "../common.h" + +/** + * Interface for objects that want to receive callbacks for touch screen + * input events. + */ +class TouchscreenListener +{ +public: + /** + * Callback for when a touch point is down (pressed). + * @param id the unique ID of the touch point + * @param x the X coordinate of the touch point + * @param y the Y coordinate of the touch point + * @param isPrimary TRUE if the touch screen input device class + * considers this touch point to be the primary one + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnTouchDown(int32_t id, uint16_t x, uint16_t y, BOOL isPrimary) = 0; + + /** + * Callback for when a touch point is up (released). + * @param id the unique ID of the touch point + * @param isPrimary TRUE if the touch screen input device class + * considers this touch point to be the primary one + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnTouchUp(int32_t id, BOOL isPrimary) = 0; + + /** + * Callback for when the touch point moves. + * @param id the unique ID of the touch point + * @param x the new X coordinate of the touch point + * @param y the new Y coordinate of the touch point + * @param deltaX amount the touch point moved since the last move event along the X axis + * @param deltaY amount the touch point moved since the last move event along the Y axis + * @param isPrimary TRUE if the touch screen input device class + * considers this touch point to be the primary one + * @return TRUE if no further listener callbacks of this kind should + * be invoked until the next event occurs + */ + virtual BOOL OnTouchMove(int32_t id, uint16_t x, uint16_t y, int16_t deltaX, int16_t deltaY, BOOL isPrimary) = 0; +}; + +#endif + diff --git a/src/framework/log.cpp b/src/framework/log.cpp new file mode 100644 index 0000000..d95fe5d --- /dev/null +++ b/src/framework/log.cpp @@ -0,0 +1,113 @@ +#include "log.h" + +#include +#include +#include +#include +#ifndef __S3E__ +#include +#endif + +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#define WIN32_EXTRA_LEAN +#include +#endif + +#ifdef __S3E__ +#include "s3eDebug.h" +#endif + +FILE *g_fpLog = NULL; +const char *g_logFilename = "run.log"; + +const size_t LOG_BUFFER_SIZE = 8096; +char _tempBuffer[LOG_BUFFER_SIZE]; +char _buffer[LOG_BUFFER_SIZE]; + +void LogStart() +{ +#ifdef DESKTOP + g_fpLog = fopen(g_logFilename, "w"); + if (!g_fpLog) + { + snprintf(_buffer, LOG_BUFFER_SIZE, "Log file \"%s\" could not be opened. Further LogWrite() calls will only appear in STDOUT.\n", g_logFilename); + printf("%s", _buffer); +#ifdef _MSC_VER + OutputDebugStringA(_buffer); +#endif + return; + } +#endif +} + +void LogEnd() +{ +#ifdef DESKTOP + if (g_fpLog) + fclose(g_fpLog); +#endif +} + +void LogWrite(const char *tag, const char *category, const char *format, ...) +{ + static char timestamp[15]; + + int hour; + int minute; + int second; + unsigned int milliseconds; + +#ifdef __S3E__ + struct timeval tv; + gettimeofday(&tv, NULL); + struct tm *currentDate = localtime(&tv.tv_sec); + + hour = currentDate->tm_hour; + minute = currentDate->tm_min; + second = currentDate->tm_sec; + milliseconds = (unsigned int)((tv.tv_usec / 1000.0) + 0.5); +#else + timeb seconds; + ftime(&seconds); + struct tm *currentDate = localtime(&seconds.time); + + hour = currentDate->tm_hour; + minute = currentDate->tm_min; + second = currentDate->tm_sec; + milliseconds = seconds.millitm; +#endif + + // Prepend the date/time + snprintf(timestamp, 15, "[%02d:%02d:%02d,%03d]", hour, minute, second, milliseconds); + + // now the user-provided format string and arguments... + va_list args; + va_start(args, format); + vsnprintf(_tempBuffer, LOG_BUFFER_SIZE, format, args); + va_end(args); + + // write it all out + // if there was a category supplied, then add that in too + if (category != NULL) + snprintf(_buffer, LOG_BUFFER_SIZE, "%s [%s] [%s] %s", timestamp, tag, category, _tempBuffer); + else + snprintf(_buffer, LOG_BUFFER_SIZE, "%s [%s] %s", timestamp, tag, _tempBuffer); + + if (g_fpLog) + fprintf(g_fpLog, "%s", _buffer); +#ifdef DESKTOP + printf("%s", _buffer); +#ifdef _MSC_VER + OutputDebugStringA(_buffer); +#endif +#endif +#ifdef __S3E__ +#ifdef DEBUG + s3eDebugTraceLine(_buffer); +#else + // ensures our own logging output still gets output in ARM release builds + printf("%s", _buffer); +#endif +#endif +} diff --git a/src/framework/log.h b/src/framework/log.h new file mode 100644 index 0000000..8616c80 --- /dev/null +++ b/src/framework/log.h @@ -0,0 +1,40 @@ +#ifndef __FRAMEWORK_LOG_H_INCLUDED__ +#define __FRAMEWORK_LOG_H_INCLUDED__ + +#include + +#include "logcategories.h" + +#define LOG_INFO(c, ...) (LogWrite("INFO", c, __VA_ARGS__)) +#define LOG_WARN(c, ...) (LogWrite("WARN", c, __VA_ARGS__)) +#define LOG_ERROR(c, ...) (LogWrite("ERROR", c, __VA_ARGS__)) +#ifdef DEBUG + #define LOG_DEBUG(c, ...) (LogWrite("DEBUG", c, __VA_ARGS__)) +#else + #define LOG_DEBUG(c, ...) +#endif + +extern FILE *g_fpLog; +extern const char *g_logFilename; + +/** + * Opens the log file for writing. If the open fails, any LogWrite calls will + * only output logging information to STDOUT. + */ +void LogStart(); + +/** + * Closes the log file. + */ +void LogEnd(); + +/** + * Writes a message to the debugging log and stdout. + * @param tag short string to tag the log message with + * @param category short string to categorize the log message with + * @param format the message to write (automatically prefixed + * with timestamp) + */ +void LogWrite(const char *tag, const char *category, const char *format, ...); + +#endif diff --git a/src/framework/logcategories.h b/src/framework/logcategories.h new file mode 100644 index 0000000..f5a5913 --- /dev/null +++ b/src/framework/logcategories.h @@ -0,0 +1,13 @@ +#ifndef __FRAMEWORK_LOGCATEGORIES_H_INCLUDED__ +#define __FRAMEWORK_LOGCATEGORIES_H_INCLUDED__ + +#define LOGCAT_DEBUG "DEBUG" +#define LOGCAT_SYSTEM "SYSTEM" +#define LOGCAT_WINDOW "WINDOW" +#define LOGCAT_GAMEAPP "GAMEAPP" +#define LOGCAT_ASSETS "ASSETS" +#define LOGCAT_FILEIO "FILEIO" +#define LOGCAT_GRAPHICS "GRAPHICS" +#define LOGCAT_OPENGL "OPENGL" + +#endif diff --git a/src/framework/marmaladegamewindow.cpp b/src/framework/marmaladegamewindow.cpp new file mode 100644 index 0000000..139b8da --- /dev/null +++ b/src/framework/marmaladegamewindow.cpp @@ -0,0 +1,488 @@ +#ifdef __S3E__ +#include "common.h" + +#include "debug.h" +#include "log.h" + +#include "basegameapp.h" +#include "marmaladegamewindow.h" +#include "marmaladesystemevent.h" +#include "screenorientation.h" +#include "graphics/glincludes.h" + +#include "s3e.h" + +MarmaladeGameWindow::MarmaladeGameWindow(BaseGameApp *gameApp, MarmaladeSystem *system) + : GameWindow(gameApp) +{ + STACK_TRACE; + m_system = system; + m_active = FALSE; + m_focused = FALSE; + m_closing = FALSE; + m_rect = Rect(0, 0, 0, 0); + m_bpp = 0; + m_fullscreen = TRUE; + m_screenOrientation = SCREEN_ANGLE_0; + m_eglContext = EGL_NO_CONTEXT; + m_eglDisplay = EGL_NO_DISPLAY; + m_eglSurface = EGL_NO_SURFACE; +} + +MarmaladeGameWindow::~MarmaladeGameWindow() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_WINDOW, "Releasing.\n"); + if (!DestroyWindow()) + LOG_ERROR(LOGCAT_WINDOW, "Failed to destroy the EGL context.\n"); +} + +BOOL MarmaladeGameWindow::Create(GameWindowParams *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_WINDOW, "Creating a window.\n"); + + LOG_INFO(LOGCAT_WINDOW, "Received window creation parameters:\n"); + LOG_INFO(LOGCAT_WINDOW, " windowed = %d\n", params->windowed); + + m_fullscreen = !params->windowed; + + // Set up the window and EGL context + if (!SetUpWindow()) + return FALSE; + + LOG_INFO(LOGCAT_WINDOW, "Finished initialization.\n"); + + LOG_INFO(LOGCAT_WINDOW, "Window marked active.\n"); + m_active = TRUE; + m_focused = TRUE; + + return TRUE; +} + +BOOL MarmaladeGameWindow::Resize(uint16_t width, uint16_t height) +{ + STACK_TRACE; + // note that the parameters are ignored completely because they don't really + // make sense for our primary/only usage of Marmalade (mobile devices) + // the parameters need to be there obviously because of the GameWindow parent + // class declaration. + ASSERT(m_eglDisplay != EGL_NO_DISPLAY); + + LOG_INFO(LOGCAT_WINDOW, "Querying for new EGL display dimensions.\n"); + + EGLint newWidth; + EGLint newHeight; + eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &newWidth); + eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_HEIGHT, &newHeight); + + LOG_INFO(LOGCAT_WINDOW, "EGL display dimensions: %dx%d\n", newWidth, newHeight); + + int surfaceWidth = s3eSurfaceGetInt(S3E_SURFACE_WIDTH); + int surfaceHeight = s3eSurfaceGetInt(S3E_SURFACE_HEIGHT); + int surfaceBpp = s3eSurfaceGetInt(S3E_SURFACE_PIXEL_TYPE) & S3E_SURFACE_PIXEL_SIZE_MASK; + + LOG_INFO(LOGCAT_WINDOW, "Surface dimensions resized to %dx%d with a bpp of %d.\n", surfaceWidth, surfaceHeight, surfaceBpp); + + m_rect.left = 0; + m_rect.top = 0; + m_rect.right = surfaceWidth; + m_rect.bottom = surfaceHeight; + m_bpp = surfaceBpp; + + LOG_INFO(LOGCAT_WINDOW, "Window content area set to %d, %d, %d, %d\n", m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); + + SCREEN_ORIENTATION_ANGLE angle = GetCurrentScreenOrientationAngle(); + LOG_INFO(LOGCAT_WINDOW, "Device's current screen orientation angle: %d\n", angle); + m_screenOrientation = angle; + + return TRUE; +} + +BOOL MarmaladeGameWindow::ToggleFullscreen() +{ + STACK_TRACE; + ASSERT(!"Not implemented."); + return FALSE; +} + +BOOL MarmaladeGameWindow::SetUpWindow() +{ + STACK_TRACE; + if (!SetUpEGL()) + { + LOG_ERROR(LOGCAT_WINDOW, "EGL setup not completed successfully.\n"); + return FALSE; + } + + return TRUE; +} + +BOOL MarmaladeGameWindow::DestroyWindow() +{ + STACK_TRACE; + if (!DestroyEGL()) + { + LOG_ERROR(LOGCAT_WINDOW, "EGL destroy not completed successfully.\n"); + return FALSE; + } + + return TRUE; +} + +BOOL MarmaladeGameWindow::SetUpEGL() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_WINDOW, "Connecting to EGL display server.\n"); + EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (display == EGL_NO_DISPLAY) + { + LOG_ERROR(LOGCAT_WINDOW, "eglGetDisplay() failed.\n"); + return FALSE; + } + + LOG_INFO(LOGCAT_WINDOW, "Initializing EGL.\n"); + if (eglInitialize(display, 0, 0) == EGL_FALSE) + { + EGLint initError = eglGetError(); + if (initError == EGL_BAD_DISPLAY) + LOG_ERROR(LOGCAT_WINDOW, "eglInitialize() failed: EGL_BAD_DISPLAY\n"); + else if (initError == EGL_NOT_INITIALIZED) + LOG_ERROR(LOGCAT_WINDOW, "eglInitialize() failed: EGL_NOT_INITIALIZED\n"); + else + LOG_ERROR(LOGCAT_WINDOW, "eglInitialize() failed.\n"); + return FALSE; + } + + LOG_INFO(LOGCAT_WINDOW, "Querying available EGL configs.\n"); + const EGLint MAX_EGL_CONFIGS = 30; // Too much? Or good enough? + EGLint numConfigsFound = 0; + EGLConfig configs[MAX_EGL_CONFIGS]; + if (eglGetConfigs(display, configs, MAX_EGL_CONFIGS, &numConfigsFound) == EGL_FALSE) + { + LOG_ERROR(LOGCAT_WINDOW, "eglGetConfigs() failed.\n"); + return FALSE; + } + if (numConfigsFound == 0) + { + LOG_ERROR(LOGCAT_WINDOW, "eglGetConfigs() found 0 EGL configs. Aborting.\n"); + return FALSE; + } + + // TODO: these should probably come from a config file or something + EGLint desiredContextVersion = EGL_OPENGL_ES2_BIT; + EGLint desiredSurfaceType = EGL_WINDOW_BIT; + EGLint desiredBlueSize = 8; + EGLint desiredGreenSize = 8; + EGLint desiredRedSize = 8; + EGLint desiredDepthSize = 24; + + LOG_INFO(LOGCAT_WINDOW, "Found %d configs. Searching for an exact match:\n", numConfigsFound); + LOG_INFO(LOGCAT_WINDOW, " EGL_RENDERABLE_TYPE = 0x%x\n", desiredContextVersion); + LOG_INFO(LOGCAT_WINDOW, " EGL_SURFACE_TYPE = 0x%x\n", desiredSurfaceType); + LOG_INFO(LOGCAT_WINDOW, " EGL_BLUE_SIZE = %d\n", desiredBlueSize); + LOG_INFO(LOGCAT_WINDOW, " EGL_GREEN_SIZE = %d\n", desiredGreenSize); + LOG_INFO(LOGCAT_WINDOW, " EGL_RED_SIZE = %d\n", desiredRedSize); + LOG_INFO(LOGCAT_WINDOW, " EGL_DEPTH_SIZE = %d\n", desiredDepthSize); + + EGLint matchingConfigIndex = -1; + EGLConfig config; + + // first try to find an exact match + for (EGLint i = 0; i < numConfigsFound; ++i) + { + EGLint contextVersionSupport = 0; + EGLint surfaceType = 0; + EGLint blueSize = 0; + EGLint greenSize = 0; + EGLint redSize = 0; + EGLint depthSize = 0; + eglGetConfigAttrib(display, configs[i], EGL_RENDERABLE_TYPE, &contextVersionSupport); + eglGetConfigAttrib(display, configs[i], EGL_SURFACE_TYPE, &surfaceType); + eglGetConfigAttrib(display, configs[i], EGL_BLUE_SIZE, &blueSize); + eglGetConfigAttrib(display, configs[i], EGL_GREEN_SIZE, &greenSize); + eglGetConfigAttrib(display, configs[i], EGL_RED_SIZE, &redSize); + eglGetConfigAttrib(display, configs[i], EGL_DEPTH_SIZE, &depthSize); + LOG_INFO(LOGCAT_WINDOW, "Config %d: renderableType = 0x%x, type = 0x%x, b = %d, g = %d, r = %d, depth = %d\n", i, contextVersionSupport, surfaceType, blueSize, greenSize, redSize, depthSize); + if (contextVersionSupport & desiredContextVersion && surfaceType & desiredSurfaceType && blueSize == desiredBlueSize && greenSize == desiredGreenSize && redSize == desiredRedSize && depthSize == desiredDepthSize) + { + LOG_INFO(LOGCAT_WINDOW, "Found matching config: %d.\n", i); + matchingConfigIndex = i; + break; + } + } + + // if we didn't find an exact match, lets now try and find the first config + // where everything except the depth buffer size matches, but make sure + // that the config at least has a non-zero depth buffer. + // We do this as it seems like the depth buffer size is the most likely one + // that won't match our initial search criteria. + if (matchingConfigIndex == -1) + { + LOG_WARN(LOGCAT_WINDOW, "No exact config match found. Searching for first config matching:\n"); + LOG_INFO(LOGCAT_WINDOW, " EGL_RENDERABLE_TYPE = 0x%x\n", desiredContextVersion); + LOG_WARN(LOGCAT_WINDOW, " EGL_SURFACE_TYPE = 0x%x\n", desiredSurfaceType); + LOG_WARN(LOGCAT_WINDOW, " EGL_BLUE_SIZE = %d\n", desiredBlueSize); + LOG_WARN(LOGCAT_WINDOW, " EGL_GREEN_SIZE = %d\n", desiredGreenSize); + LOG_WARN(LOGCAT_WINDOW, " EGL_RED_SIZE = %d\n", desiredRedSize); + LOG_WARN(LOGCAT_WINDOW, " EGL_DEPTH_SIZE > 0\n"); + + for (EGLint i = 0; i < numConfigsFound; ++i) + { + EGLint contextVersionSupport = 0; + EGLint surfaceType = 0; + EGLint blueSize = 0; + EGLint greenSize = 0; + EGLint redSize = 0; + EGLint depthSize = 0; + eglGetConfigAttrib(display, configs[i], EGL_RENDERABLE_TYPE, &contextVersionSupport); + eglGetConfigAttrib(display, configs[i], EGL_SURFACE_TYPE, &surfaceType); + eglGetConfigAttrib(display, configs[i], EGL_BLUE_SIZE, &blueSize); + eglGetConfigAttrib(display, configs[i], EGL_GREEN_SIZE, &greenSize); + eglGetConfigAttrib(display, configs[i], EGL_RED_SIZE, &redSize); + eglGetConfigAttrib(display, configs[i], EGL_DEPTH_SIZE, &depthSize); + LOG_WARN(LOGCAT_WINDOW, "Config %d: renderableType = 0x%x, type = 0x%x, b = %d, g = %d, r = %d, depth = %d\n", i, contextVersionSupport, surfaceType, blueSize, greenSize, redSize, depthSize); + if (contextVersionSupport & desiredContextVersion && surfaceType & desiredSurfaceType && blueSize == desiredBlueSize && greenSize == desiredGreenSize && redSize == desiredRedSize && depthSize > 0) + { + LOG_WARN(LOGCAT_WINDOW, "Found matching config: %d.\n", i); + matchingConfigIndex = i; + break; + } + } + } + + // if we still didn't find a match, just use the first config from the list + if (matchingConfigIndex == -1) + { + LOG_WARN(LOGCAT_WINDOW, "No matching config found. Using config 0 from the previous list as a fallback.\n"); + matchingConfigIndex = 0; + } + + config = configs[matchingConfigIndex]; + + LOG_INFO(LOGCAT_WINDOW, "Creating EGL window.\n"); + void *nativeWindowHandle = s3eGLGetNativeWindow(); + EGLSurface surface = eglCreateWindowSurface(display, config, nativeWindowHandle, NULL); + if (surface == EGL_NO_SURFACE) + { + LOG_ERROR(LOGCAT_WINDOW, "eglCreateWindowSurface() failed.\n"); + return FALSE; + } + + LOG_INFO(LOGCAT_WINDOW, "Creating rendering context.\n"); + EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, }; + EGLContext context = eglCreateContext(display, config, NULL, contextAttribs); + if (context == EGL_NO_CONTEXT) + { + LOG_ERROR(LOGCAT_WINDOW, "eglCreateContext() failed.\n"); + return FALSE; + } + + LOG_INFO(LOGCAT_WINDOW, "Making this rendering context current.\n"); + if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) + { + LOG_ERROR(LOGCAT_WINDOW, "eglMakeCurrent() failed.\n"); + return FALSE; + } + + LOG_INFO(LOGCAT_WINDOW, "EGL window set up successfully.\n"); + + EGLint width; + EGLint height; + eglQuerySurface(display, surface, EGL_WIDTH, &width); + eglQuerySurface(display, surface, EGL_HEIGHT, &height); + + LOG_INFO(LOGCAT_WINDOW, "EGL display dimensions: %dx%d\n", width, height); + + m_eglDisplay = display; + m_eglSurface = surface; + m_eglContext = context; + + int surfaceWidth = s3eSurfaceGetInt(S3E_SURFACE_WIDTH); + int surfaceHeight = s3eSurfaceGetInt(S3E_SURFACE_HEIGHT); + int surfaceBpp = s3eSurfaceGetInt(S3E_SURFACE_PIXEL_TYPE) & S3E_SURFACE_PIXEL_SIZE_MASK; + + LOG_INFO(LOGCAT_WINDOW, "Surface dimensions of %dx%d with a bpp of %d.\n", surfaceWidth, surfaceHeight, surfaceBpp); + + m_rect.left = 0; + m_rect.top = 0; + m_rect.right = surfaceWidth; + m_rect.bottom = surfaceHeight; + m_bpp = surfaceBpp; + + LOG_INFO(LOGCAT_WINDOW, "Window content area set to %d, %d, %d, %d\n", m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); + + SCREEN_ORIENTATION_ANGLE angle = GetCurrentScreenOrientationAngle(); + LOG_INFO(LOGCAT_WINDOW, "Device's current screen orientation angle: %d\n", angle); + m_screenOrientation = angle; + + return TRUE; +} + +BOOL MarmaladeGameWindow::DestroyEGL() +{ + STACK_TRACE; + if (m_eglDisplay != EGL_NO_DISPLAY) + { + LOG_INFO(LOGCAT_WINDOW, "Destroying EGL context.\n"); + + // Used to check the return value from this call, but it seems that every code sample, + // article, book, or whatever doesn't do that ever. And this seems to always fail in + // the Marmalade simulator (return EGL_FALSE). + eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + + if (m_eglContext != EGL_NO_CONTEXT) + { + if (eglDestroyContext(m_eglDisplay, m_eglContext) == EGL_FALSE) + { + LOG_ERROR(LOGCAT_WINDOW, "Error destroying EGL context.\n"); + return FALSE; + } + } + if (m_eglSurface != EGL_NO_SURFACE) + { + if (eglDestroySurface(m_eglDisplay, m_eglSurface) == EGL_FALSE) + { + LOG_ERROR(LOGCAT_WINDOW, "Error destroying EGL surface.\n"); + return FALSE; + } + } + if (eglTerminate(m_eglDisplay) == EGL_FALSE) + { + LOG_ERROR(LOGCAT_WINDOW, "Error terminating EGL display.\n"); + return FALSE; + } + } + m_eglDisplay = EGL_NO_DISPLAY; + m_eglContext = EGL_NO_CONTEXT; + m_eglSurface = EGL_NO_SURFACE; + + return TRUE; +} + +SCREEN_ORIENTATION_ANGLE MarmaladeGameWindow::GetCurrentScreenOrientationAngle() +{ + STACK_TRACE; + s3eSurfaceBlitDirection direction = (s3eSurfaceBlitDirection)s3eSurfaceGetInt(S3E_SURFACE_DEVICE_BLIT_DIRECTION); + + SCREEN_ORIENTATION_ANGLE angle = SCREEN_ANGLE_0; + switch (direction) + { + case S3E_SURFACE_BLIT_DIR_NORMAL: + case S3E_SURFACE_BLIT_DIR_NATIVE: + angle = SCREEN_ANGLE_0; + break; + case S3E_SURFACE_BLIT_DIR_ROT90: + angle = SCREEN_ANGLE_90; + break; + case S3E_SURFACE_BLIT_DIR_ROT180: + angle = SCREEN_ANGLE_180; + break; + case S3E_SURFACE_BLIT_DIR_ROT270: + angle = SCREEN_ANGLE_270; + break; + } + + return angle; +} + +void MarmaladeGameWindow::Close() +{ + STACK_TRACE; + if (m_active) + { + LOG_INFO(LOGCAT_WINDOW, "Window marked inactive.\n"); + m_active = FALSE; + m_focused = FALSE; + } + else + LOG_INFO(LOGCAT_WINDOW, "Window was already marked inactive.\n"); + + LOG_INFO(LOGCAT_WINDOW, "Closing.\n"); + m_closing = TRUE; +} + +void MarmaladeGameWindow::ProcessEvent(const OSEvent *event) +{ + STACK_TRACE; + if (IsClosing()) + return; + + MarmaladeSystemEvent *eventArgs = (MarmaladeSystemEvent*)event; + + switch (eventArgs->event) + { + case MARMALADE_EVENT_PAUSE: + LOG_INFO(LOGCAT_WINDOW, "Event: MARMALADE_EVENT_PAUSE\n"); + if (m_active) + { + LOG_INFO(LOGCAT_WINDOW, "Window marked inactive.\n"); + m_active = FALSE; + m_focused = FALSE; + LOG_INFO(LOGCAT_WINDOW, "Lost input device focus.\n"); + GetGameApp()->OnAppLostFocus(); + LOG_INFO(LOGCAT_WINDOW, "Pausing app.\n"); + GetGameApp()->OnAppPause(); + } + else + LOG_INFO(LOGCAT_WINDOW, "Window was already marked inactive.\n"); + break; + + case MARMALADE_EVENT_RESUME: + LOG_INFO(LOGCAT_WINDOW, "Event: MARMALADE_EVENT_RESUME\n"); + if (!m_active) + { + LOG_INFO(LOGCAT_WINDOW, "Window marked active.\n"); + m_active = TRUE; + m_focused = TRUE; + LOG_INFO(LOGCAT_WINDOW, "Resuming app.\n"); + GetGameApp()->OnAppResume(); + LOG_INFO(LOGCAT_WINDOW, "Gained input device focus.\n"); + GetGameApp()->OnAppGainFocus(); + } + else + LOG_INFO(LOGCAT_WINDOW, "Window was already marked active.\n"); + break; + + case MARMALADE_EVENT_GLSUSPEND: + LOG_INFO(LOGCAT_WINDOW, "Event: MARMALADE_EVENT_GLSUSPEND\n"); + GetGameApp()->OnLostContext(); + if (!DestroyWindow()) + { + LOG_ERROR(LOGCAT_WINDOW, "Error destroying EGL context.\n"); + Close(); + return; + } + break; + + case MARMALADE_EVENT_GLRESUME: + LOG_INFO(LOGCAT_WINDOW, "Event: MARMALADE_EVENT_GLRESUME\n"); + if (!SetUpWindow()) + { + LOG_ERROR(LOGCAT_WINDOW, "Error creating EGL context.\n"); + Close(); + return; + } + GetGameApp()->OnNewContext(); + + // Not sure if there will ever be a case where a screen resize + // event will be raised immediately after (or before?) a GL + // resume event. If that's the case, we could end up calling + // BaseGameApp's OnResize() event twice... + GetGameApp()->OnResize(); + break; + + case MARMALADE_EVENT_SCREENRESIZE: + LOG_INFO(LOGCAT_WINDOW, "Event: MARMALADE_EVENT_SCREENRESIZE\n"); + if (!Resize()) + { + LOG_ERROR(LOGCAT_WINDOW, "Window resize failed.\n"); + Close(); + return; + } + GetGameApp()->OnResize(); + break; + } +} + +#endif diff --git a/src/framework/marmaladegamewindow.h b/src/framework/marmaladegamewindow.h new file mode 100644 index 0000000..b9db539 --- /dev/null +++ b/src/framework/marmaladegamewindow.h @@ -0,0 +1,69 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_MARMALADEGAMEWINDOW_H_INCLUDED__ +#define __FRAMEWORK_MARMALADEGAMEWINDOW_H_INCLUDED__ + +#include "common.h" + +#include "gamewindow.h" +#include "screenorientation.h" +#include "graphics/glincludes.h" +#include "math/rect.h" + +class MarmaladeSystem; +class BaseGameApp; + +#define IGNORE_DIMENSIONS 0 + +class MarmaladeGameWindow : public GameWindow +{ +public: + MarmaladeGameWindow(BaseGameApp *gameApp, MarmaladeSystem *system); + virtual ~MarmaladeGameWindow(); + + BOOL Create(GameWindowParams *params); + BOOL Resize(uint16_t width = IGNORE_DIMENSIONS, uint16_t height = IGNORE_DIMENSIONS); + BOOL ToggleFullscreen(); + void Close(); + + uint16_t GetWidth() const { return m_rect.GetWidth(); } + uint16_t GetHeight() const { return m_rect.GetHeight(); } + const Rect& GetRect() const { return m_rect; } + uint8_t GetBPP() const { return m_bpp; } + BOOL IsWindowed() const { return !m_fullscreen; } + SCREEN_ORIENTATION_ANGLE GetScreenOrientation() const { return m_screenOrientation; } + + BOOL IsActive() const { return m_active; } + BOOL IsFocused() const { return m_focused; } + BOOL IsClosing() const { return m_closing; } + BOOL HasGLContext() const { return eglGetCurrentContext() != EGL_NO_CONTEXT; } + + void ProcessEvent(const OSEvent *event); + void Flip() { eglSwapBuffers(m_eglDisplay, m_eglSurface); } + +private: + BOOL SetUpWindow(); + BOOL DestroyWindow(); + + BOOL SetUpEGL(); + BOOL DestroyEGL(); + + SCREEN_ORIENTATION_ANGLE GetCurrentScreenOrientationAngle(); + + MarmaladeSystem *m_system; + + BOOL m_active; + BOOL m_focused; + BOOL m_closing; + + Rect m_rect; + uint8_t m_bpp; + BOOL m_fullscreen; + SCREEN_ORIENTATION_ANGLE m_screenOrientation; + + EGLDisplay m_eglDisplay; + EGLSurface m_eglSurface; + EGLContext m_eglContext; +}; + +#endif +#endif diff --git a/src/framework/marmaladesystem.cpp b/src/framework/marmaladesystem.cpp new file mode 100644 index 0000000..995f6ef --- /dev/null +++ b/src/framework/marmaladesystem.cpp @@ -0,0 +1,489 @@ +#ifdef __S3E__ +#include "common.h" + +#include "debug.h" +#include "log.h" + +#include "marmaladesystem.h" +#include "marmaladesystemevent.h" +#include "operatingsystem.h" +#include "basegameapp.h" +#include "gamewindow.h" +#include "marmaladegamewindow.h" +#include "file/marmaladefilesystem.h" +#include "graphics/glincludes.h" +#include "input/marmaladekeyboard.h" +#include "input/marmalademouse.h" +#include "input/marmaladetouchscreen.h" + +#include "s3e.h" +#include "MarmaladeVersion.h" + +#include + +int32 _MarmaladeEventCallback_Pause(void *systemData, void *userData); +int32 _MarmaladeEventCallback_Resume(void *systemData, void *userData); +int32 _MarmaladeEventCallback_Exit(void *systemData, void *userData); +int32 _MarmaladeEventCallback_GLSuspend(void *systemData, void *userData); +int32 _MarmaladeEventCallback_GLResume(void *systemData, void *userData); +int32 _MarmaladeEventCallback_ScreenResize(void *systemData, void *userData); +int32 _MarmaladeEventCallback_Key(void *systemData, void *userData); +int32 _MarmaladeEventCallback_KeyChar(void *systemData, void *userData); +int32 _MarmaladeEventCallback_PointerButton(void *systemData, void *userData); +int32 _MarmaladeEventCallback_PointerMotion(void *systemData, void *userData); +int32 _MarmaladeEventCallback_PointerMultitouchButton(void *systemData, void *userData); +int32 _MarmaladeEventCallback_PointerMultitouchMotion(void *systemData, void *userData); +int32_t _MarmaladeEvent_PassToSystem(MARMALADE_EVENT event, void *systemData, void *userData); + +MarmaladeSystem::MarmaladeSystem() + : OperatingSystem() +{ + STACK_TRACE; + m_isQuitting = FALSE; + m_window = NULL; + m_filesystem = NULL; + m_keyboard = NULL; + m_mouse = NULL; + m_touchscreen = NULL; + m_hasShaderSupport = FALSE; + m_supportedShaderVersion = 0.0f; +} + +MarmaladeSystem::~MarmaladeSystem() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "Releasing.\n"); + + if (!m_isQuitting) + { + LOG_WARN(LOGCAT_SYSTEM, "Was not signaled to quit. Calling Quit() now.\n"); + Quit(); + } + + SAFE_DELETE(m_window); + + SAFE_DELETE(m_filesystem); + SAFE_DELETE(m_keyboard); + SAFE_DELETE(m_mouse); + SAFE_DELETE(m_touchscreen); +} + +BOOL MarmaladeSystem::Initialize() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "MarmaladeSystem initialization starting.\n"); + + const char* marmaladeRuntimeVersion = s3eDeviceGetString(S3E_DEVICE_SDK_VERSION); + LOG_INFO(LOGCAT_SYSTEM, "Marmalade Runtime Version %s, Linked Version %s\n", marmaladeRuntimeVersion, MARMALADE_VERSION_STRING); + + const char* s3eRuntimeVersion = s3eDeviceGetString(S3E_DEVICE_S3E_VERSION); + LOG_INFO(LOGCAT_SYSTEM, "S3E Runtime Version: %s, Linked Version: %s\n", s3eRuntimeVersion, S3E_VERSION_STRING); + + const char* deviceID = s3eDeviceGetString(S3E_DEVICE_ID); + const char* deviceOS = s3eDeviceGetString(S3E_DEVICE_OS); + int32 deviceOsVersion = s3eDeviceGetInt(S3E_DEVICE_OS_VERSION); + int osVersionMajor = (deviceOsVersion >> 16); + int osVersionMinor = deviceOsVersion & 0xffff; + const char* deviceClass = s3eDeviceGetString(S3E_DEVICE_CLASS); + const char* deviceArch = s3eDeviceGetString(S3E_DEVICE_ARCHITECTURE); + const char* deviceChipset = s3eDeviceGetString(S3E_DEVICE_CHIPSET); + int32 deviceTotalMemKB = s3eDeviceGetInt(S3E_DEVICE_MEM_TOTAL); + int32 deviceFreeMemKB = s3eDeviceGetInt(S3E_DEVICE_MEM_FREE); + int32 heapSize = s3eMemoryGetInt(S3E_MEMORY_SIZE); + + LOG_INFO(LOGCAT_SYSTEM, "Device ID: %s\n", deviceID); + LOG_INFO(LOGCAT_SYSTEM, "Device OS: %s (%d.%d)\n", deviceOS, osVersionMajor, osVersionMinor); + LOG_INFO(LOGCAT_SYSTEM, "Device Class: %s\n", deviceClass); + LOG_INFO(LOGCAT_SYSTEM, "Device Architecture: %s\n", deviceArch); + LOG_INFO(LOGCAT_SYSTEM, "Device Chipset: %s\n", deviceChipset); + LOG_INFO(LOGCAT_SYSTEM, "Device Memory: %dKB free, %dKB total\n", deviceFreeMemKB, deviceTotalMemKB); + LOG_INFO(LOGCAT_SYSTEM, "S3E Memory Heap Size: %d bytes\n", heapSize); + + BOOL keyboardHasAlpha = FALSE; + BOOL keyboardHasDirection = FALSE; + if (s3eKeyboardGetInt(S3E_KEYBOARD_HAS_ALPHA)) + { + keyboardHasAlpha = TRUE; + LOG_INFO(LOGCAT_SYSTEM, "Keyboard property: S3E_KEYBOARD_HAS_ALPHA\n"); + } + if (s3eKeyboardGetInt(S3E_KEYBOARD_HAS_NUMPAD)) + LOG_INFO(LOGCAT_SYSTEM, "Keyboard property: S3E_KEYBOARD_HAS_NUMPAD\n"); + if (s3eKeyboardGetInt(S3E_KEYBOARD_HAS_DIRECTION)) + { + keyboardHasDirection = TRUE; + LOG_INFO(LOGCAT_SYSTEM, "Keyboard property: S3E_KEYBOARD_HAS_DIRECTION\n"); + } + + // Android Xperia Play device detection + // TODO: any other device ID's we need to worry about? + BOOL isXperiaPlay = FALSE; + if (s3eDeviceGetInt(S3E_DEVICE_OS) == S3E_OS_ID_ANDROID) + { + LOG_INFO(LOGCAT_SYSTEM, "Detected Android as host OS.\n"); + if (strlen(deviceID) >= 4) + { + // possible device ID's I currently know of: + // R800i, R800a, R800x + if (strncmp(deviceID, "R800", 4) == 0) + { + LOG_INFO(LOGCAT_SYSTEM, "Device is an Xperia Play.\n"); + isXperiaPlay = TRUE; + } + else + LOG_INFO(LOGCAT_SYSTEM, "Device is not an Xperia Play.\n"); + } + } + + BOOL keyboardHasPhysicalGameControls = FALSE; + if ((keyboardHasAlpha && keyboardHasDirection) || isXperiaPlay) + keyboardHasPhysicalGameControls = TRUE; + + if (keyboardHasPhysicalGameControls) + LOG_INFO(LOGCAT_SYSTEM, "Keyboard device has enough physical keys for full game controls.\n"); + else + LOG_INFO(LOGCAT_SYSTEM, "Keyboard device does not have enough physical keys for full game controls.\n"); + + m_keyboard = new MarmaladeKeyboard(keyboardHasPhysicalGameControls); + ASSERT(m_keyboard != NULL); + LOG_INFO(LOGCAT_SYSTEM, "Keyboard input device ready.\n"); + + BOOL isMultitouchAvailable = FALSE; + if (s3ePointerGetInt(S3E_POINTER_AVAILABLE)) + { + s3ePointerType pointerType = (s3ePointerType)s3ePointerGetInt(S3E_POINTER_TYPE); + if (pointerType == S3E_POINTER_TYPE_INVALID) + LOG_ERROR(LOGCAT_SYSTEM, "Pointer type = S3E_POINTER_TYPE_INVALID\n"); + else if (pointerType == S3E_POINTER_TYPE_MOUSE) + { + LOG_INFO(LOGCAT_SYSTEM, "Pointer device is a mouse.\n"); + + m_mouse = new MarmaladeMouse(); + ASSERT(m_mouse != NULL); + LOG_INFO(LOGCAT_SYSTEM, "Mouse input device ready.\n"); + } + else if (pointerType == S3E_POINTER_TYPE_STYLUS) + { + s3eStylusType stylusType = (s3eStylusType)s3ePointerGetInt(S3E_POINTER_STYLUS_TYPE); + if (stylusType == S3E_STYLUS_TYPE_INVALID) + LOG_ERROR(LOGCAT_SYSTEM, "Stylus type = S3E_STYLUS_TYPE_INVALID\n"); + else + { + if (stylusType == S3E_STYLUS_TYPE_STYLUS) + LOG_INFO(LOGCAT_SYSTEM, "Pointer device is a touchscreen using a stylus.\n"); + else if (stylusType == S3E_STYLUS_TYPE_FINGER) + LOG_INFO(LOGCAT_SYSTEM, "Pointer device is a touchscreen.\n"); + + if (s3ePointerGetInt(S3E_POINTER_MULTI_TOUCH_AVAILABLE)) + { + LOG_INFO(LOGCAT_SYSTEM, "Pointer device supports multitouch.\n"); + isMultitouchAvailable = TRUE; + } + else + LOG_INFO(LOGCAT_SYSTEM, "Pointer device does not support multitouch.\n"); + + m_touchscreen = new MarmaladeTouchscreen(this, isMultitouchAvailable); + ASSERT(m_touchscreen != NULL); + LOG_INFO(LOGCAT_SYSTEM, "Touchscreen input device ready.\n"); + } + } + } + else + LOG_WARN(LOGCAT_SYSTEM, "No pointer device is available.\n"); + + s3eDeviceRegister(S3E_DEVICE_PAUSE, _MarmaladeEventCallback_Pause, this); + s3eDeviceRegister(S3E_DEVICE_UNPAUSE, _MarmaladeEventCallback_Resume, this); + s3eDeviceRegister(S3E_DEVICE_EXIT, _MarmaladeEventCallback_Exit, this); + s3eGLRegister(S3E_GL_SUSPEND, _MarmaladeEventCallback_GLSuspend, this); + s3eGLRegister(S3E_GL_RESUME, _MarmaladeEventCallback_GLResume, this); + s3eSurfaceRegister(S3E_SURFACE_SCREENSIZE, _MarmaladeEventCallback_ScreenResize, this); + s3eKeyboardRegister(S3E_KEYBOARD_KEY_EVENT, _MarmaladeEventCallback_Key, this); + s3eKeyboardRegister(S3E_KEYBOARD_CHAR_EVENT, _MarmaladeEventCallback_KeyChar, this); + if (m_mouse != NULL || m_touchscreen != NULL) + { + if (isMultitouchAvailable) + { + s3ePointerRegister(S3E_POINTER_TOUCH_EVENT, _MarmaladeEventCallback_PointerMultitouchButton, this); + s3ePointerRegister(S3E_POINTER_TOUCH_MOTION_EVENT, _MarmaladeEventCallback_PointerMultitouchMotion, this); + } + else + { + s3ePointerRegister(S3E_POINTER_BUTTON_EVENT, _MarmaladeEventCallback_PointerButton, this); + s3ePointerRegister(S3E_POINTER_MOTION_EVENT, _MarmaladeEventCallback_PointerMotion, this); + } + } + else + LOG_WARN(LOGCAT_SYSTEM, "No mouse or touchscreen device was initialized.\n"); + + LOG_INFO(LOGCAT_SYSTEM, "Registered S3E event callbacks.\n"); + + LOG_INFO(LOGCAT_SYSTEM, "Initializing file system access.\n"); + m_filesystem = new MarmaladeFileSystem(); + ASSERT(m_filesystem != NULL); + + LOG_INFO(LOGCAT_SYSTEM, "Finished initialization.\n"); + + return TRUE; +} + +BOOL MarmaladeSystem::CreateGameWindow(BaseGameApp *gameApp, GameWindowParams *params) +{ + STACK_TRACE; + ASSERT(m_window == NULL); + + MarmaladeGameWindow *window = new MarmaladeGameWindow(gameApp, this); + ASSERT(window != NULL); + + if (!window->Create(params)) + { + LOG_ERROR(LOGCAT_SYSTEM, "Failed to create a GameWindow.\n"); + return FALSE; + } + + m_window = window; + + int32 glVersion = s3eGLGetInt(S3E_GL_VERSION); + int glVersionMajor = (glVersion >> 8) & 0xff; + int glVersionMinor = glVersion & 0xff; + int32 eglVersion = s3eGLGetInt(S3E_EGL_VERSION); + int eglVersionMajor = (eglVersion >> 8) & 0xff; + int eglVersionMinor = eglVersion & 0xff; + int32 glMustSuspend = s3eGLGetInt(S3E_GL_MUST_SUSPEND); + + LOG_INFO(LOGCAT_SYSTEM, "GL Version: %d.%d\n", glVersionMajor, glVersionMinor); + LOG_INFO(LOGCAT_SYSTEM, "EGL Version: %d.%d\n", eglVersionMajor, eglVersionMinor); + if (glMustSuspend) + LOG_INFO(LOGCAT_SYSTEM, "Platform may require GL context to be suspended/resumed during execution.\n"); + else + LOG_INFO(LOGCAT_SYSTEM, "Platform will not require GL context to be suspended/resumed during execution.\n"); + + LOG_INFO(LOGCAT_SYSTEM, "OpenGL renderer using the following video hardware:\n"); + LOG_INFO(LOGCAT_SYSTEM, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + LOG_INFO(LOGCAT_SYSTEM, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); + LOG_INFO(LOGCAT_SYSTEM, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + LOG_INFO(LOGCAT_SYSTEM, "GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS)); + +#ifdef GL_ES_VERSION_2_0 + if (glVersionMajor >= 2) + { + m_hasShaderSupport = TRUE; + + // TOD: shader version detection? (who cares?) + m_supportedShaderVersion = 0.0f; + + LOG_INFO(LOGCAT_SYSTEM, "Version of OpenGL supports using shaders.\n"); + LOG_INFO(LOGCAT_SYSTEM, "GL_SHADING_LANGUAGE_VERSION: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); + } + else + { + m_hasShaderSupport = FALSE; + m_supportedShaderVersion = 0.0f; + + LOG_INFO(LOGCAT_SYSTEM, "Version of OpenGL supports fixed function pipeline only.\n"); + } +#endif + + LOG_INFO(LOGCAT_SYSTEM, "GameWindow instance is ready.\n"); + + return TRUE; +} + +void MarmaladeSystem::ProcessEvents() +{ + STACK_TRACE; + // need to manually reset deltas for the Mouse/Touchscreen device objects + // since we use callbacks to get state updates. as a result of using + // callbacks, the deltas won't ever get reset to zero when motion of these + // devices stops (because callbacks are only fired for *motion* events). + // also need to make sure we do this before the s3eDeviceYield call as + // that will trigger this ticks callbacks (99% sure anyway, from testing). + if (m_mouse != NULL) + m_mouse->ResetDeltas(); + if (m_touchscreen != NULL) + { + m_touchscreen->ResetDeltas(); + // also need to re-supply the touchscreen with a new view bounds rect so it can clamp x/y coords + m_touchscreen->ResetViewBounds(m_window->GetRect()); + } + + s3eDeviceYield(0); +} + +int32_t MarmaladeSystem::OnEvent(const MarmaladeSystemEvent *eventArgs) +{ + STACK_TRACE; + switch (eventArgs->event) + { + case MARMALADE_EVENT_PAUSE: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_PAUSE. Passing to GameWindow.\n"); + ASSERT(m_window != NULL); + m_window->ProcessEvent(eventArgs); + break; + + case MARMALADE_EVENT_RESUME: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_RESUME. Passing to GameWindow.\n"); + ASSERT(m_window != NULL); + m_window->ProcessEvent(eventArgs); + break; + + case MARMALADE_EVENT_EXIT: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_EXIT.\n"); + ASSERT(m_window != NULL); + m_window->Close(); + break; + + case MARMALADE_EVENT_GLSUSPEND: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_GLSUSPEND. Passing to GameWindow.\n"); + ASSERT(m_window != NULL); + m_window->ProcessEvent(eventArgs); + break; + + case MARMALADE_EVENT_GLRESUME: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_GLRESUME. Passing to GameWindow.\n"); + ASSERT(m_window != NULL); + m_window->ProcessEvent(eventArgs); + break; + + case MARMALADE_EVENT_SCREENRESIZE: + LOG_INFO(LOGCAT_SYSTEM, "Event: MARMALADE_EVENT_SCREENRESIZE. Passing to GameWindow.\n"); + ASSERT(m_window != NULL); + m_window->ProcessEvent(eventArgs); + break; + + case MARMALADE_EVENT_KEY: + ASSERT(m_keyboard != NULL); + m_keyboard->OnKeyEvent((s3eKeyboardEvent*)eventArgs->data); + break; + + case MARMALADE_EVENT_KEYCHAR: + ASSERT(m_keyboard != NULL); + m_keyboard->OnKeyCharEvent((s3eKeyboardCharEvent*)eventArgs->data); + break; + + case MARMALADE_EVENT_POINTER_BUTTON: + ASSERT(m_mouse != NULL || m_touchscreen != NULL); + if (m_mouse != NULL) + m_mouse->OnButtonEvent((s3ePointerEvent*)eventArgs->data); + else if (m_touchscreen != NULL) + m_touchscreen->OnSingleTouchTapEvent((s3ePointerEvent*)eventArgs->data); + break; + + case MARMALADE_EVENT_POINTER_MOTION: + ASSERT(m_mouse != NULL || m_touchscreen != NULL); + if (m_mouse != NULL) + m_mouse->OnMotionEvent((s3ePointerMotionEvent*)eventArgs->data); + else if (m_touchscreen != NULL) + m_touchscreen->OnSingleTouchMotionEvent((s3ePointerMotionEvent*)eventArgs->data); + break; + + case MARMALADE_EVENT_POINTER_MULTITOUCH_BUTTON: + ASSERT(m_touchscreen != NULL); + m_touchscreen->OnMultiTouchTapEvent((s3ePointerTouchEvent*)eventArgs->data); + break; + + case MARMALADE_EVENT_POINTER_MULTITOUCH_MOTION: + ASSERT(m_touchscreen != NULL); + m_touchscreen->OnMultiTouchMotionEvent((s3ePointerTouchMotionEvent*)eventArgs->data); + break; + } + + return 0; +} + +void MarmaladeSystem::Quit() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "Quit requested.\n"); + m_isQuitting = TRUE; + + if (m_window != NULL && !m_window->IsClosing()) + { + LOG_INFO(LOGCAT_SYSTEM, "Signaling window to close.\n"); + m_window->Close(); + } +} + +void MarmaladeSystem::Delay(uint32_t milliseconds) const +{ + STACK_TRACE; + unsigned int start = GetTicks(); + unsigned int elapsed = 0; + + do + { + elapsed = GetTicks() - start; + } + while (milliseconds > elapsed); +} + +int32 _MarmaladeEventCallback_Pause(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_PAUSE, systemData, userData); +} + +int32 _MarmaladeEventCallback_Resume(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_RESUME, systemData, userData); +} + +int32 _MarmaladeEventCallback_Exit(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_EXIT, systemData, userData); +} + +int32 _MarmaladeEventCallback_GLSuspend(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_GLSUSPEND, systemData, userData); +} + +int32 _MarmaladeEventCallback_GLResume(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_GLRESUME, systemData, userData); +} + +int32 _MarmaladeEventCallback_ScreenResize(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_SCREENRESIZE, systemData, userData); +} + +int32 _MarmaladeEventCallback_Key(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_KEY, systemData, userData); +} + +int32 _MarmaladeEventCallback_KeyChar(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_KEYCHAR, systemData, userData); +} + +int32 _MarmaladeEventCallback_PointerButton(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_POINTER_BUTTON, systemData, userData); +} + +int32 _MarmaladeEventCallback_PointerMotion(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_POINTER_MOTION, systemData, userData); +} + +int32 _MarmaladeEventCallback_PointerMultitouchButton(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_POINTER_MULTITOUCH_BUTTON, systemData, userData); +} + +int32 _MarmaladeEventCallback_PointerMultitouchMotion(void *systemData, void *userData) +{ + return _MarmaladeEvent_PassToSystem(MARMALADE_EVENT_POINTER_MULTITOUCH_MOTION, systemData, userData); +} + +int32_t _MarmaladeEvent_PassToSystem(MARMALADE_EVENT event, void *systemData, void *userData) +{ + STACK_TRACE; + MarmaladeSystemEvent eventArgs; + eventArgs.event = event; + eventArgs.data = systemData; + + MarmaladeSystem *system = (MarmaladeSystem*)userData; + return system->OnEvent(&eventArgs); +} + +#endif diff --git a/src/framework/marmaladesystem.h b/src/framework/marmaladesystem.h new file mode 100644 index 0000000..fcaf112 --- /dev/null +++ b/src/framework/marmaladesystem.h @@ -0,0 +1,64 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_MARMALADESYSTEM_H_INCLUDED__ +#define __FRAMEWORK_MARMALADESYSTEM_H_INCLUDED__ + +#include "common.h" + +#include "operatingsystem.h" +#include "s3eTimer.h" + +class MarmaladeFileSystem; +class MarmaladeGameWindow; +class MarmaladeKeyboard; +class MarmaladeMouse; +class MarmaladeTouchscreen; +class BaseGameApp; +class FileSystem; +class GameWindow; +class Mouse; +class Keyboard; +class Touchscreen; +struct GameWindowParams; +struct MarmaladeSystemEvent; + +class MarmaladeSystem : public OperatingSystem +{ +public: + MarmaladeSystem(); + virtual ~MarmaladeSystem(); + + BOOL Initialize(); + BOOL CreateGameWindow(BaseGameApp *gameApp, GameWindowParams *params); + void ProcessEvents(); + int32_t OnEvent(const MarmaladeSystemEvent *eventArgs); + void Quit(); + + BOOL IsQuitting() const { return m_isQuitting; } + + BOOL HasShaderSupport() const { return m_hasShaderSupport; } + float GetSupportedShaderVersion() const { return m_supportedShaderVersion; } + + GameWindow* GetWindow() const { return (GameWindow*)m_window; } + FileSystem* GetFileSystem() const { return (FileSystem*)m_filesystem; } + Mouse* GetMouse() const { return (Mouse*)m_mouse; } + Keyboard* GetKeyboard() const { return (Keyboard*)m_keyboard; } + Touchscreen* GetTouchscreen() const { return (Touchscreen*)m_touchscreen; } + + uint32_t GetTicks() const { return (uint32_t)s3eTimerGetMs(); } + void Delay(uint32_t milliseconds) const; + +private: + BOOL m_isQuitting; + + MarmaladeGameWindow *m_window; + MarmaladeFileSystem *m_filesystem; + MarmaladeKeyboard *m_keyboard; + MarmaladeMouse *m_mouse; + MarmaladeTouchscreen *m_touchscreen; + + BOOL m_hasShaderSupport; + float m_supportedShaderVersion; +}; + +#endif +#endif diff --git a/src/framework/marmaladesystemevent.h b/src/framework/marmaladesystemevent.h new file mode 100644 index 0000000..a7ad2e5 --- /dev/null +++ b/src/framework/marmaladesystemevent.h @@ -0,0 +1,31 @@ +#ifdef __S3E__ +#ifndef __FRAMEWORK_MARMALADESYSTEMEVENT_H_INCLUDED__ +#define __FRAMEWORK_MARMALADESYSTEMEVENT_H_INCLUDED__ + +#include "common.h" +#include "osevent.h" + +enum MARMALADE_EVENT +{ + MARMALADE_EVENT_PAUSE, + MARMALADE_EVENT_RESUME, + MARMALADE_EVENT_EXIT, + MARMALADE_EVENT_GLSUSPEND, + MARMALADE_EVENT_GLRESUME, + MARMALADE_EVENT_SCREENRESIZE, + MARMALADE_EVENT_KEY, + MARMALADE_EVENT_KEYCHAR, + MARMALADE_EVENT_POINTER_BUTTON, + MARMALADE_EVENT_POINTER_MOTION, + MARMALADE_EVENT_POINTER_MULTITOUCH_BUTTON, + MARMALADE_EVENT_POINTER_MULTITOUCH_MOTION +}; + +struct MarmaladeSystemEvent : OSEvent +{ + MARMALADE_EVENT event; + void *data; +}; + +#endif +#endif diff --git a/src/framework/math/boundingbox.cpp b/src/framework/math/boundingbox.cpp new file mode 100644 index 0000000..f33a5e1 --- /dev/null +++ b/src/framework/math/boundingbox.cpp @@ -0,0 +1,64 @@ +#include "../debug.h" + +#include "boundingbox.h" + +#include "../common.h" + +BoundingBox::BoundingBox(const Vector3 *vertices, int numVertices) +{ + STACK_TRACE; + ASSERT(vertices != NULL); + ASSERT(numVertices > 0); + float minX = 0.0f; + float minY = 0.0f; + float minZ = 0.0f; + float maxX = 0.0f; + float maxY = 0.0f; + float maxZ = 0.0f; + + for (int i = 0; i < numVertices; ++i) + { + minX = Min(vertices[i].x, minX); + minY = Min(vertices[i].y, minY); + minZ = Min(vertices[i].z, minZ); + maxX = Max(vertices[i].x, maxX); + maxY = Max(vertices[i].y, maxY); + maxZ = Max(vertices[i].z, maxZ); + } + + this->min = Vector3(minX, minY, minZ); + this->max = Vector3(maxX, maxY, maxZ); +} + +float BoundingBox::GetSquaredDistanceFromPointToBox(const Vector3 &point, const BoundingBox &box) +{ + STACK_TRACE; + float distanceSq = 0.0f; + float v; + + v = point.x; + if (v < box.min.x) + distanceSq += (box.min.x - v) * (box.min.x - v); + if (v > box.max.x) + distanceSq += (v - box.max.x) * (v - box.max.x); + + v = point.y; + if (v < box.min.y) + distanceSq += (box.min.y - v) * (box.min.y - v); + if (v > box.max.y) + distanceSq += (v - box.max.y) * (v - box.max.y); + + v = point.z; + if (v < box.min.z) + distanceSq += (box.min.z - v) * (box.min.z - v); + if (v > box.max.z) + distanceSq += (v - box.max.z) * (v - box.max.z); + + return distanceSq; +} + +float BoundingBox::GetDistanceFromPointToBox(const Vector3 &point, const BoundingBox &box) +{ + STACK_TRACE; + return sqrtf(GetSquaredDistanceFromPointToBox(point, box)); +} diff --git a/src/framework/math/boundingbox.h b/src/framework/math/boundingbox.h new file mode 100644 index 0000000..7756ecc --- /dev/null +++ b/src/framework/math/boundingbox.h @@ -0,0 +1,140 @@ +#ifndef __FRAMEWORK_MATH_BOUNDINGBOX_H_INCLUDED__ +#define __FRAMEWORK_MATH_BOUNDINGBOX_H_INCLUDED__ + +#include "point3.h" +#include "vector3.h" +#include + +/** + * Represents an axis-aligned bounding box (AABB) in 3D space. + */ +struct BoundingBox +{ + /** + * Creates a box centered on the origin with zero-length dimensions. + */ + BoundingBox(); + + /** + * Creates a box with the specified properties. + * @param min the minimum point of the box (should be less then max) + * @param max the maximum point of the box (should be greater then min) + */ + BoundingBox(const Vector3 &min, const Vector3 &max); + + /** + * @param minX X coordinate of the minimum point of the box (should be less then maxX) + * @param minY Y coordinate of the minimum point of the box (should be less then maxY) + * @param minZ Z coordinate of the minimum point of the box (should be less then maxZ) + * @param maxX X coordinate of the maximum point of the box (should be greater then minX) + * @param maxY Y coordinate of the maximum point of the box (should be greater then minY) + * @param maxZ Z coordinate of the maximum point of the box (should be greater then minZ) + */ + BoundingBox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ); + + /** + * Creates a box with the specified properties. + * @param min the minimum point of the box (should be less then max) + * @param max the maximum point of the box (should be greater then min) + */ + BoundingBox(const Point3 &min, const Point3 &max); + + /** + * Creates a box that will be automatically sized and positioned + * to fully enclose a set of vertices. + * @param vertices an array of vertices to be fully enclosed within the box + * @param numVertices the number of vertices being passed + */ + BoundingBox(const Vector3 *vertices, int numVertices); + + /** + * Creates a box with the specified properties. + * @param center the center point of the box + * @param halfWidth the distance from the center to the edge of the box + * on the X, Y and Z axis' + */ + BoundingBox(const Vector3 ¢er, float halfWidth); + + /** + * @return the absolute width of the box (X axis length) + */ + float GetWidth() const; + + /** + * @return the absolute height of the box (Y axis length) + */ + float GetHeight() const; + + /** + * @return the absolute depth of the box (Z axis length) + */ + float GetDepth() const; + + /** + * Returns the squared absolute distance from a point to the nearest + * edge of the given box. + * @param point the point + * @param box the box + * @return float the squared distance from point to box + */ + static float GetSquaredDistanceFromPointToBox(const Vector3 &point, const BoundingBox &box); + + /** + * Returns the absolute distance from a point to the nearest edge of + * @param point the point + * @param box the box + * @return float the distance from point to box + */ + static float GetDistanceFromPointToBox(const Vector3 &point, const BoundingBox &box); + + Vector3 min; + Vector3 max; +}; + +inline BoundingBox::BoundingBox() +{ + min = ZERO_VECTOR; + max = ZERO_VECTOR; +} + +inline BoundingBox::BoundingBox(const Vector3 &min, const Vector3 &max) +{ + this->min = min; + this->max = max; +} + +inline BoundingBox::BoundingBox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) +{ + this->min = Vector3(minX, minY, minZ); + this->max = Vector3(maxX, maxY, maxZ); +} + +inline BoundingBox::BoundingBox(const Point3 &min, const Point3 &max) +{ + this->min = Vector3((float)min.x, (float)min.y, (float)min.z); + this->max = Vector3((float)max.x, (float)max.y, (float)max.z); +} + +inline BoundingBox::BoundingBox(const Vector3 ¢er, float halfWidth) +{ + this->min = Vector3(center.x - halfWidth, center.y - halfWidth, center.z - halfWidth); + this->max = Vector3(center.x + halfWidth, center.y + halfWidth, center.z + halfWidth); +} + +inline float BoundingBox::GetWidth() const +{ + return fabsf(max.x - min.x); +} + +inline float BoundingBox::GetHeight() const +{ + return fabsf(max.y - min.y); +} + +inline float BoundingBox::GetDepth() const +{ + return fabsf(max.z - min.z); +} + +#endif + diff --git a/src/framework/math/boundingsphere.cpp b/src/framework/math/boundingsphere.cpp new file mode 100644 index 0000000..b71303d --- /dev/null +++ b/src/framework/math/boundingsphere.cpp @@ -0,0 +1,80 @@ +#include "../debug.h" + +#include "boundingsphere.h" + +#include + +BoundingSphere::BoundingSphere(const Vector3 *vertices, int numVertices) +{ + STACK_TRACE; + ASSERT(vertices != NULL); + ASSERT(numVertices > 0); + + int min; + int max; + + int minX = 0; + int minY = 0; + int minZ = 0; + int maxX = 0; + int maxY = 0; + int maxZ = 0; + + // find min & max points for x, y and z + for (int i = 0; i < numVertices; ++i) + { + if (vertices[i].x < vertices[minX].x) + minX = i; + if (vertices[i].x > vertices[maxX].x) + maxX = i; + if (vertices[i].y < vertices[minY].y) + minY = i; + if (vertices[i].y > vertices[maxY].y) + maxY = i; + if (vertices[i].z < vertices[minZ].z) + minZ = i; + if (vertices[i].z > vertices[maxZ].z) + maxZ = i; + } + + // distances between these extremes for x, y and z + float distanceSqX = Vector3::Dot(vertices[maxX] - vertices[minX], vertices[maxX] - vertices[minX]); + float distanceSqY = Vector3::Dot(vertices[maxY] - vertices[minY], vertices[maxY] - vertices[minY]); + float distanceSqZ = Vector3::Dot(vertices[maxZ] - vertices[minZ], vertices[maxZ] - vertices[minZ]); + + // get the pair of points representing the most distance points from each other + min = minX; + max = maxX; + if (distanceSqY > distanceSqX && distanceSqY > distanceSqZ) + { + min = minY; + max = maxY; + } + if (distanceSqZ > distanceSqX && distanceSqZ > distanceSqY) + { + min = minZ; + max = maxZ; + } + + // we now have enough info to set the initial sphere properties + center = (vertices[min] + vertices[max]) / 2.0f; + radius = sqrtf(Vector3::Dot(vertices[max] - center, vertices[max] - center)); + + // now expand the sphere to make sure it encompasses all the points (if it doesn't already) + Vector3 d; + for (int i = 0; i < numVertices; ++i) + { + d = vertices[i] - center; + float distanceSq = Vector3::Dot(d, d); + if (distanceSq > (radius * radius)) + { + float distance = sqrtf(distanceSq); + float newRadius = (radius + distance) * 0.5f; + float k = (newRadius - radius) / distance; + radius = newRadius; + d = d * k; + center = center + d; + } + } +} + diff --git a/src/framework/math/boundingsphere.h b/src/framework/math/boundingsphere.h new file mode 100644 index 0000000..9ca7a91 --- /dev/null +++ b/src/framework/math/boundingsphere.h @@ -0,0 +1,63 @@ +#ifndef __FRAMEWORK_MATH_BOUNDINGSPHERE_H_INCLUDED__ +#define __FRAMEWORK_MATH_BOUNDINGSPHERE_H_INCLUDED__ + +#include "vector3.h" + +/** + * Represents a sphere in 3D space. + */ +struct BoundingSphere +{ + /** + * Creates a sphere centered on the origin with a zero-length radius. + */ + BoundingSphere(); + + /** + * Creates a sphere with the specified properties. + * @param center the center point of the sphere + * @@param radius the sphere's radius + */ + BoundingSphere(const Vector3 ¢er, float radius); + + /** + * Creates a sphere with the specified properties. + * @param centerX X coordinate of the sphere's center point + * @param centerY Y coordinate of the sphere's center point + * @param centerZ Z coordinate of the sphere's center point + * @param radius the sphere's radius + */ + BoundingSphere(float centerX, float centerY, float centerZ, float radius); + + /** + * Creates a sphere that will be automatically sized and positioned + * to fully enclose a set of vertices. + * @param vertices an array of vertices to be fully enclosed within the sphere + * @param numVertices the number of vertices being passed + */ + BoundingSphere(const Vector3 *vertices, int numVertices); + + Vector3 center; + float radius; +}; + +inline BoundingSphere::BoundingSphere() +{ + center = ZERO_VECTOR; + radius = 0.0f; +} + +inline BoundingSphere::BoundingSphere(const Vector3 ¢er, float radius) +{ + this->center = center; + this->radius = radius; +} + +inline BoundingSphere::BoundingSphere(float centerX, float centerY, float centerZ, float radius) +{ + this->center = Vector3(centerX, centerY, centerZ); + this->radius = radius; +} + +#endif + diff --git a/src/framework/math/camera.cpp b/src/framework/math/camera.cpp new file mode 100644 index 0000000..19ff04d --- /dev/null +++ b/src/framework/math/camera.cpp @@ -0,0 +1,178 @@ +#include "../debug.h" + +#include "camera.h" +#include "frustum.h" +#include "mathhelpers.h" +#include "point2.h" +#include "ray.h" +#include "rect.h" +#include "../graphics/viewcontext.h" + +Camera::Camera(ViewContext *viewContext) +{ + STACK_TRACE; + m_viewContext = viewContext; + m_frustum = new Frustum(m_viewContext); + ASSERT(m_frustum != NULL); + m_position = ZERO_VECTOR; + m_orientation = ZERO_VECTOR; + m_forward = ZERO_VECTOR; + m_up = UP; + m_lookAt = IDENTITY_MATRIX; + + // fairly typical defaults + m_fovAngle = 60.0f; + m_near = 1.0f; + m_far = 50.0f; + + CalculateDefaultProjection( + m_viewContext->GetViewportLeft(), + m_viewContext->GetViewportTop(), + m_viewContext->GetViewportRight(), + m_viewContext->GetViewportBottom() + ); +} + +Camera::~Camera() +{ + STACK_TRACE; + SAFE_DELETE(m_frustum); +} + +void Camera::CalculateDefaultProjection(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) +{ + STACK_TRACE; + m_viewportWidth = right - left; + m_viewportHeight = bottom - top; + + m_aspectRatio = (float)m_viewportWidth / (float)m_viewportHeight; + + m_nearHeight = m_near * tanf(DegreesToRadians(m_fovAngle / 2.0f)); + m_nearWidth = m_nearHeight * m_aspectRatio; + + m_projection = Matrix4x4::CreatePerspectiveFieldOfView(DegreesToRadians(m_fovAngle), m_aspectRatio, m_near, m_far); +} + +void Camera::CalculateDefaultLookAt(const Vector3 &movement) +{ + STACK_TRACE; + // final camera orientation. angles must be negative (or rather, inverted) for the camera matrix. also the matrix concatenation order is important! + Matrix4x4 rotation = Matrix4x4::CreateRotationY(-m_orientation.y) * Matrix4x4::CreateRotationX(-m_orientation.x); + + // apply orientation to forward, movement and up vectors so they're pointing in the right direction + m_forward = FORWARD * rotation; + m_up = UP * rotation; + Vector3 orientedMovement = movement * rotation; + + // move the camera position + m_position += orientedMovement; + + Vector3 target = m_forward + m_position; + m_lookAt = Matrix4x4::CreateLookAt(m_position, target, UP); +} + +void Camera::OnUpdate(float delta) +{ + STACK_TRACE; +} + +void Camera::OnRender() +{ + STACK_TRACE; + UpdateLookAtMatrix(ZERO_VECTOR); + m_viewContext->SetModelViewMatrix(m_lookAt); + m_frustum->Calculate(); +} + +void Camera::OnResize(const Rect &size) +{ + STACK_TRACE; + CalculateDefaultProjection(size.left, size.top, size.right, size.bottom); + m_viewContext->SetProjectionMatrix(m_projection); +} + +void Camera::UpdateLookAtMatrix(const Vector3 &movement) +{ + STACK_TRACE; + CalculateDefaultLookAt(movement); +} + +void Camera::UpdateProjectionMatrix() +{ + STACK_TRACE; + CalculateDefaultProjection( + m_viewContext->GetViewportLeft(), + m_viewContext->GetViewportTop(), + m_viewContext->GetViewportRight(), + m_viewContext->GetViewportBottom() + ); +} + +Ray Camera::Pick(uint16_t screenX, uint16_t screenY) const +{ + STACK_TRACE; + float nx = 2.0f * ((float)(screenX - (m_viewContext->GetViewportWidth() / 2))) / ((float)m_viewContext->GetViewportWidth()); + float ny = 2.0f * -((float)(screenY - (m_viewContext->GetViewportHeight() / 2))) / ((float)m_viewContext->GetViewportHeight()); + + // pick ray calculation method copied from http://code.google.com/p/libgdx/ + Vector3 vz = Vector3::Normalize(m_forward * -1.0f); + Vector3 vx = Vector3::Normalize(Vector3::Cross(UP, vz)); + Vector3 vy = Vector3::Normalize(Vector3::Cross(vz, vx)); + + Vector3 near_center = m_position - (vz * m_near); + + Vector3 a = (vx * m_nearWidth) * nx; + Vector3 b = (vy * m_nearHeight) * ny; + Vector3 near_point = a + b + near_center; + + Vector3 dir = Vector3::Normalize(near_point - m_position); + + return Ray(m_position, dir); +} + +Point2 Camera::Project(const Vector3 &objectPosition) const +{ + STACK_TRACE; + Matrix4x4 modelview = m_viewContext->GetModelViewMatrix(); + Matrix4x4 projection = m_viewContext->GetProjectionMatrix(); + + return Project(objectPosition, modelview, projection); +} + +Point2 Camera::Project(const Vector3 &objectPosition, const Matrix4x4 &modelview, const Matrix4x4 &projection) const +{ + STACK_TRACE; + // transform object position by modelview matrix (vector transform, w = 1) + float tempX = objectPosition.x * modelview.m[_11] + objectPosition.y * modelview.m[_12] + objectPosition.z * modelview.m[_13] + modelview.m[_14]; + float tempY = objectPosition.x * modelview.m[_21] + objectPosition.y * modelview.m[_22] + objectPosition.z * modelview.m[_23] + modelview.m[_24]; + float tempZ = objectPosition.x * modelview.m[_31] + objectPosition.y * modelview.m[_32] + objectPosition.z * modelview.m[_33] + modelview.m[_34]; + float tempW = objectPosition.x * modelview.m[_41] + objectPosition.y * modelview.m[_42] + objectPosition.z * modelview.m[_43] + modelview.m[_44]; + + // transform the above by the projection matrix (optimized for bottom row of the projection matrix always being [0, 0, -1, 0]) + float transformedX = tempX * projection.m[_11] + tempY * projection.m[_12] + tempZ * projection.m[_13] + tempW * projection.m[_14]; + float transformedY = tempX * projection.m[_21] + tempY * projection.m[_22] + tempZ * projection.m[_23] + tempW * projection.m[_24]; + float transformedZ = tempX * projection.m[_31] + tempY * projection.m[_32] + tempZ * projection.m[_33] + tempW * projection.m[_34]; + float transformedW = -tempZ; + + // w normalizes between -1 and 1 + // TODO: shouldn't really handle this using an assert... however, I'd like to know when/if this happens + ASSERT(transformedW != 0.0f); + transformedW = 1.0f / transformedW; + + // perspective division + transformedX *= transformedW; + transformedY *= transformedW; + transformedZ *= transformedW; + + // map to 2D viewport coordinates (ignoring Z) + Point2 out; + out.x = (int32_t)(((transformedX * 0.5f) + 0.5f) * (float)m_viewContext->GetViewportWidth() + (float)m_viewContext->GetViewportLeft()); + out.y = (int32_t)(((transformedY * 0.5f) + 0.5f) * (float)m_viewContext->GetViewportHeight() + (float)m_viewContext->GetViewportTop()); + // float z = (1.0f + transformedZ) * 0.5f; // would be between 0.0f and 1.0f + + // adjust Y coordinate so that 0 is at the top of the screen instead of the bottom + out.y = (int32_t)m_viewContext->GetViewportHeight() - out.y; + + return out; +} + diff --git a/src/framework/math/camera.h b/src/framework/math/camera.h new file mode 100644 index 0000000..ae8f007 --- /dev/null +++ b/src/framework/math/camera.h @@ -0,0 +1,214 @@ +#ifndef __FRAMEWORK_MATH_CAMERA_H_INCLUDED__ +#define __FRAMEWORK_MATH_CAMERA_H_INCLUDED__ + +#include "vector3.h" +#include "matrix4x4.h" +#include "../common.h" + +class Frustum; +class ViewContext; +struct Ray; +struct Rect; +struct Point2; + +/** + * Base class for Camera objects. + */ +class Camera +{ +public: + /** + * Creates a camera object. + * @param viewContext the view context object this camera is associated with + */ + Camera(ViewContext *viewContext); + + virtual ~Camera(); + + /** + * Update (tick) callback. + * @param delta time since last update + */ + virtual void OnUpdate(float delta); + + /** + * Render callback. + */ + virtual void OnRender(); + + /** + * Viewport resize callback. + * @param size new size of the viewport + */ + virtual void OnResize(const Rect &size); + + /** + * Recalculates the projection matrix using the viewport dimensions + * currently set on the parent ViewContext. This is normally done inside + * the OnResize() callback for most camera implementations and won't + * need to be called manually. + */ + virtual void UpdateProjectionMatrix(); + + /** + * Recalculates the "look at" matrix. This is normally done inside + * the OnRender() callback for most camera implementations and won't + * need to be called manually. + * @param movement amount to move the camera by. This will be oriented by + * the current camera orientation. + */ + virtual void UpdateLookAtMatrix(const Vector3 &movement = ZERO_VECTOR); + + /** + * Convert 2D screen coordinates to a 3D ray that originates from the + * 3D coordinates that coorespond to the 2D screen coordinates and has + * a direction that points "into" the 3D world from this point. + * @param screenX 2D X coordinate in screen space + * @param screenY 2D Y coordinate in screen space + * @return Ray a ray originating from the given 2D screen space coordinates + */ + Ray Pick(uint16_t screenX, uint16_t screenY) const; + + /** + * Projects the given 3D coordinates into 2D screen space coordinates. + * @param objectPosition 3D world position to be converted. + * @return Point2 "projected" 2D screen space coordinates corresponding + * with the given 3D coordinates + */ + Point2 Project(const Vector3 &objectPosition) const; + + /** + * Projects the given 3D coordinates into 2D screen space coordinates. + * Instead of using the camera object's current modelview and projection + * matrices, this will use those matrices specified. + * @param objectPosition 3D world position to be converted. + * @param modelview modelview matrix to use in the coordinate projection operation + * @param projection projection matrix to use in the coordinate projection operation + * @return Point2 "projected" 2D screen space coordinates corresponding + * with the given 3D coordinates + */ + Point2 Project(const Vector3 &objectPosition, const Matrix4x4 &modelview, const Matrix4x4 &projection) const; + + /** + * @return the camera's frustum object + */ + const Frustum* GetFrustum() const { return m_frustum; } + + /** + * @return the camera's "look at" matrix + */ + const Matrix4x4& GetLookAt() const { return m_lookAt; } + + /** + * @return the camera's projection matrix + */ + const Matrix4x4& GetProjection() const { return m_projection; } + + /** + * @return a vector containing the camera's current X, Y, and Z axis + * orientations + */ + Vector3& GetOrientation() { return m_orientation; } + + /** + * @return a vector containing the camera's current X, Y, and Z axis + * orientations + */ + const Vector3& GetOrientation() const { return m_orientation; } + + /** + * @return the current position of the camera + */ + Vector3& GetPosition() { return m_position; } + + /** + * @return the current position of the camera + */ + const Vector3& GetPosition() const { return m_position; } + + /** + * @return the direction the camera facing + */ + Vector3& GetForward() { return m_forward; } + + /** + * @return the direction the camera facing + */ + const Vector3& GetForward() const { return m_forward; } + + /** + * @return the "up" vector of the camera which is adjusted by it's + * current orientation + */ + Vector3& GetUp() { return m_up; } + + /** + * @return the "up" vector of the camera which is adjusted by it's + * current orientation + */ + const Vector3& GetUp() const { return m_up; } + + /** + * @return the width of the camera's current viewport + */ + uint16_t GetViewportWidth() const { return m_viewportWidth; } + + /** + * @return the height of the camera's current viewport + */ + uint16_t GetViewportHeight() const { return m_viewportHeight; } + + /** + * @return the aspect ratio of the camera's current viewport + */ + float GetAspectRatio() const { return m_aspectRatio; } + + /** + * @return the distance to the near clipping plane + */ + float GetNearDistance() const { return m_near; } + + /** + * @return the distance to the far clipping plane + */ + float GetFarDistance() const { return m_far; } + +protected: + /** + * Calculates a default projection matrix using the viewport dimensions. + * @param left left X coordinate of the viewport + * @param top top Y coordinate of the viewport + * @param right right X coordinate of the viewport + * @param bottom bottom Y coordinate of the viewport + */ + void CalculateDefaultProjection(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom); + + /** + * Calculates a default "look at" matrix to position and orient the camera. + * @param movement amount to move the camera by. This will be oriented by + * the current camera orientation. + */ + void CalculateDefaultLookAt(const Vector3 &movement); + +private: + float m_fovAngle; + float m_aspectRatio; + float m_near; + float m_far; + float m_nearHeight; + float m_nearWidth; + + uint16_t m_viewportWidth; + uint16_t m_viewportHeight; + + ViewContext *m_viewContext; + Frustum *m_frustum; + Matrix4x4 m_lookAt; + Matrix4x4 m_projection; + Vector3 m_orientation; + Vector3 m_position; + Vector3 m_forward; + Vector3 m_up; +}; + +#endif diff --git a/src/framework/math/circle.h b/src/framework/math/circle.h new file mode 100644 index 0000000..c75c20b --- /dev/null +++ b/src/framework/math/circle.h @@ -0,0 +1,66 @@ +#ifndef __FRAMEWORK_MATH_CIRCLE_H_INCLUDED__ +#define __FRAMEWORK_MATH_CIRCLE_H_INCLUDED__ + +#include "../common.h" + +/** + * Represents a 2D circle. + */ +struct Circle +{ + /** + * Creates an uninitialized circle. + */ + Circle(); + + /** + * Creates a circle with the specified properties. + * @param x X coordinate of the circle's center point + * @param y Y coordinate of the circle's center point + * @param radius the radius of the circle + */ + Circle(int32_t x, int32_t y, uint32_t radius); + + /** + * Set new properties for this circle. + * @param x X coordinate of the circle's center point + * @param y Y coordinate of the circle's center point + * @param radius the radius of the circle + */ + void Set(int32_t x, int32_t y, uint32_t radius); + + /** + * @return the circle's diameter + */ + int32_t GetDiameter() const; + + int32_t x; + int32_t y; + uint32_t radius; +}; + +inline Circle::Circle() +{ +} + +inline Circle::Circle(int32_t x, int32_t y, uint32_t radius) +{ + this->x = x; + this->y = y; + this->radius = radius; +} + +inline void Circle::Set(int32_t x, int32_t y, uint32_t radius) +{ + this->x = x; + this->y = y; + this->radius = radius; +} + +inline int32_t Circle::GetDiameter() const +{ + return radius * 2; +} + +#endif + diff --git a/src/framework/math/collisionpacket.h b/src/framework/math/collisionpacket.h new file mode 100644 index 0000000..ee0aa2c --- /dev/null +++ b/src/framework/math/collisionpacket.h @@ -0,0 +1,36 @@ +#ifndef __FRAMEWORK_MATH_COLLISIONPACKET_H_INCLUDED__ +#define __FRAMEWORK_MATH_COLLISIONPACKET_H_INCLUDED__ + +#include "../common.h" +#include "vector3.h" + +struct CollisionPacket +{ + // defines the x/y/z radius of the entity being checked + Vector3 ellipsoidRadius; + + BOOL foundCollision; + float nearestDistance; + + // the below fields are all in "ellipsoid space" + + Vector3 esVelocity; // velocity of the entity + Vector3 esNormalizedVelocity; + Vector3 esPosition; // current position of the entity + + Vector3 esIntersectionPoint; // if an intersection is found + + CollisionPacket() + { + ellipsoidRadius = ZERO_VECTOR; + foundCollision = FALSE; + nearestDistance = 0.0f; + esVelocity = ZERO_VECTOR; + esNormalizedVelocity = ZERO_VECTOR; + esPosition = ZERO_VECTOR; + esIntersectionPoint = ZERO_VECTOR; + } +}; + +#endif + diff --git a/src/framework/math/common.h b/src/framework/math/common.h new file mode 100644 index 0000000..0c05686 --- /dev/null +++ b/src/framework/math/common.h @@ -0,0 +1,24 @@ +#ifndef __FRAMEWORK_MATH_COMMON_H_INCLUDED__ +#define __FRAMEWORK_MATH_COMMON_H_INCLUDED__ + +const float PI = 3.141593f; // 180 degrees +const float HALF_PI = PI / 2.0f; // 90 degrees +const float QUARTER_PI = PI / 4.0f; // 45 degrees +const float TWO_PI = PI * 2.0f; // 360 degrees + +const float RADIANS_0 = 0.0f; +const float RADIANS_45 = PI / 4.0f; +const float RADIANS_90 = PI / 2.0f; +const float RADIANS_135 = (3.0f * PI) / 4.0f; +const float RADIANS_180 = PI; +const float RADIANS_225 = (5.0f * PI) / 4.0f; +const float RADIANS_270 = (3.0f * PI) / 2.0f; +const float RADIANS_315 = (7.0f * PI) / 4.0f; +const float RADIANS_360 = PI * 2.0f; + +const float PI_OVER_180 = PI / 180.0f; + +const float TOLERANCE = 0.00001f; +const float EPSILON = 0.0005f; + +#endif diff --git a/src/framework/math/frustum.cpp b/src/framework/math/frustum.cpp new file mode 100644 index 0000000..0d2057c --- /dev/null +++ b/src/framework/math/frustum.cpp @@ -0,0 +1,151 @@ +#include "../debug.h" + +#include "frustum.h" + +#include "boundingbox.h" +#include "boundingsphere.h" +#include "matrix4x4.h" +#include "../graphics/viewcontext.h" +#include "../graphics/graphicsdevice.h" + +Frustum::Frustum(ViewContext *viewContext) +{ + STACK_TRACE; + m_viewContext = viewContext; + Calculate(); +} + +Frustum::~Frustum() +{ + STACK_TRACE; +} + +void Frustum::Calculate() +{ + STACK_TRACE; + Matrix4x4 projection = m_viewContext->GetProjectionMatrix(); + Matrix4x4 modelview = m_viewContext->GetModelViewMatrix(); + + Matrix4x4 combined = projection * modelview; + + // Extract the sides of each of the 6 planes from this to get our viewing frustum + m_planes[FRUSTUM_RIGHT].normal.x = combined.m[_41] - combined.m[_11]; + m_planes[FRUSTUM_RIGHT].normal.y = combined.m[_42] - combined.m[_12]; + m_planes[FRUSTUM_RIGHT].normal.z = combined.m[_43] - combined.m[_13]; + m_planes[FRUSTUM_RIGHT].d = combined.m[_44] - combined.m[_14]; + + m_planes[FRUSTUM_LEFT].normal.x = combined.m[_41] + combined.m[_11]; + m_planes[FRUSTUM_LEFT].normal.y = combined.m[_42] + combined.m[_12]; + m_planes[FRUSTUM_LEFT].normal.z = combined.m[_43] + combined.m[_13]; + m_planes[FRUSTUM_LEFT].d = combined.m[_44] + combined.m[_14]; + + m_planes[FRUSTUM_BOTTOM].normal.x = combined.m[_41] + combined.m[_21]; + m_planes[FRUSTUM_BOTTOM].normal.y = combined.m[_42] + combined.m[_22]; + m_planes[FRUSTUM_BOTTOM].normal.z = combined.m[_43] + combined.m[_23]; + m_planes[FRUSTUM_BOTTOM].d = combined.m[_44] + combined.m[_24]; + + m_planes[FRUSTUM_TOP].normal.x = combined.m[_41] - combined.m[_21]; + m_planes[FRUSTUM_TOP].normal.y = combined.m[_42] - combined.m[_22]; + m_planes[FRUSTUM_TOP].normal.z = combined.m[_43] - combined.m[_23]; + m_planes[FRUSTUM_TOP].d = combined.m[_44] - combined.m[_24]; + + m_planes[FRUSTUM_BACK].normal.x = combined.m[_41] - combined.m[_31]; + m_planes[FRUSTUM_BACK].normal.y = combined.m[_42] - combined.m[_32]; + m_planes[FRUSTUM_BACK].normal.z = combined.m[_43] - combined.m[_33]; + m_planes[FRUSTUM_BACK].d = combined.m[_44] - combined.m[_34]; + + m_planes[FRUSTUM_FRONT].normal.x = combined.m[_41] + combined.m[_31]; + m_planes[FRUSTUM_FRONT].normal.y = combined.m[_42] + combined.m[_32]; + m_planes[FRUSTUM_FRONT].normal.z = combined.m[_43] + combined.m[_33]; + m_planes[FRUSTUM_FRONT].d = combined.m[_44] + combined.m[_34]; + + m_planes[FRUSTUM_RIGHT] = Plane::Normalize(m_planes[FRUSTUM_RIGHT]); + m_planes[FRUSTUM_LEFT] = Plane::Normalize(m_planes[FRUSTUM_LEFT]); + m_planes[FRUSTUM_BOTTOM] = Plane::Normalize(m_planes[FRUSTUM_BOTTOM]); + m_planes[FRUSTUM_TOP] = Plane::Normalize(m_planes[FRUSTUM_TOP]); + m_planes[FRUSTUM_BACK] = Plane::Normalize(m_planes[FRUSTUM_BACK]); + m_planes[FRUSTUM_FRONT] = Plane::Normalize(m_planes[FRUSTUM_FRONT]); +} + +BOOL Frustum::Test(const Vector3 &point) const +{ + STACK_TRACE; + for (int p = 0; p < NUM_FRUSTUM_SIDES; ++p) + { + if (Plane::ClassifyPoint(m_planes[p], point) == BEHIND) + return FALSE; + } + + return TRUE; +} + +BOOL Frustum::Test(const BoundingBox &box) const +{ + STACK_TRACE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_RIGHT], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_LEFT], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_BOTTOM], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_TOP], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_BACK], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + if (!TestPlaneAgainstBox(m_planes[FRUSTUM_FRONT], box.min.x, box.min.y, box.min.z, box.GetWidth(), box.GetHeight(), box.GetDepth())) + return FALSE; + + return TRUE; +} + +BOOL Frustum::Test(const BoundingSphere &sphere) const +{ + STACK_TRACE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_RIGHT], sphere.center, sphere.radius)) + return FALSE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_LEFT], sphere.center, sphere.radius)) + return FALSE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_BOTTOM], sphere.center, sphere.radius)) + return FALSE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_TOP], sphere.center, sphere.radius)) + return FALSE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_BACK], sphere.center, sphere.radius)) + return FALSE; + if (!TestPlaneAgainstSphere(m_planes[FRUSTUM_FRONT], sphere.center, sphere.radius)) + return FALSE; + + return TRUE; +} + +BOOL Frustum::TestPlaneAgainstBox(const Plane &plane, float minX, float minY, float minZ, float width, float height, float depth) const +{ + STACK_TRACE; + if (Plane::ClassifyPoint(plane, Vector3(minX, minY, minZ)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX, minY, minZ + depth)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX + width, minY, minZ + depth)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX + width, minY, minZ)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX, minY + height, minZ)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX, minY + height, minZ + depth)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX + width, minY + height, minZ + depth)) != BEHIND) + return TRUE; + if (Plane::ClassifyPoint(plane, Vector3(minX + width, minY + height, minZ)) != BEHIND) + return TRUE; + + return FALSE; +} + +BOOL Frustum::TestPlaneAgainstSphere(const Plane &plane, const Vector3 ¢er, float radius) const +{ + STACK_TRACE; + float distance = Plane::DistanceBetween(plane, center); + if (distance <= -radius) + return FALSE; + else + return TRUE; +} diff --git a/src/framework/math/frustum.h b/src/framework/math/frustum.h new file mode 100644 index 0000000..34b7716 --- /dev/null +++ b/src/framework/math/frustum.h @@ -0,0 +1,74 @@ +#ifndef __FRAMEWORK_MATH_FRUSTUM_H_INCLUDED__ +#define __FRAMEWORK_MATH_FRUSTUM_H_INCLUDED__ + +#include "../common.h" +#include "plane.h" + +class ViewContext; +struct BoundingBox; +struct BoundingSphere; + +enum FRUSTUM_SIDES +{ + FRUSTUM_RIGHT = 0, + FRUSTUM_LEFT = 1, + FRUSTUM_BOTTOM = 2, + FRUSTUM_TOP = 3, + FRUSTUM_BACK = 4, + FRUSTUM_FRONT = 5 +}; + +const int32_t NUM_FRUSTUM_SIDES = 6; + +/** + * A viewing frustum that can be used to test for geometry visibility + * given the current camera modelview and projection matrices. + */ +class Frustum +{ +public: + /** + * Creates a frustum object. + * @param viewContext the view context this frustum is associated with + */ + Frustum(ViewContext *viewContext); + + virtual ~Frustum(); + + /** + * Recalculates the viewing frustum from the current camera matrices. + */ + void Calculate(); + + /** + * Tests a point for visibility. + * @param point the point to be tested + * @return BOOL TRUE if visible, FALSE if not + */ + BOOL Test(const Vector3 &point) const; + + /** + * Tests a box for visibility. + * @param box the box to be tested + * @return BOOL TRUE if at least partially visible, FALSE if entirely + * outside the viewing frustum + */ + BOOL Test(const BoundingBox &box) const; + + /** + * Tests a sphere for visibility. + * @param sphere the sphere to be tested + * @return BOOL TRUE if at least partially visible, FALSE if entirely + * outside the viewing frustum + */ + BOOL Test(const BoundingSphere &sphere) const; + +private: + BOOL TestPlaneAgainstBox(const Plane &plane, float minX, float minY, float minZ, float width, float height, float depth) const; + BOOL TestPlaneAgainstSphere(const Plane &plane, const Vector3 ¢er, float radius) const; + + ViewContext *m_viewContext; + Plane m_planes[NUM_FRUSTUM_SIDES]; +}; + +#endif diff --git a/src/framework/math/intersectiontester.cpp b/src/framework/math/intersectiontester.cpp new file mode 100644 index 0000000..5dbbf55 --- /dev/null +++ b/src/framework/math/intersectiontester.cpp @@ -0,0 +1,534 @@ +#include "../debug.h" + +#include "intersectiontester.h" + +#include +#include + +#include "collisionpacket.h" +#include "boundingbox.h" +#include "boundingsphere.h" +#include "mathhelpers.h" +#include "plane.h" +#include "ray.h" +#include "vector3.h" + +BOOL IntersectionTester::Test(const BoundingBox &box, const Vector3 &point) +{ + STACK_TRACE; + if ((point.x >= box.min.x && point.x <= box.max.x) && + (point.y >= box.min.y && point.y <= box.max.y) && + (point.z >= box.min.z && point.z <= box.max.z)) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingSphere &sphere, const Vector3 &point) +{ + STACK_TRACE; + if (fabsf(Vector3::Distance(point, sphere.center)) < sphere.radius) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingBox &box, const Vector3 *vertices, int numVertices, Vector3 *firstIntersection) +{ + STACK_TRACE; + for (int i = 0; i < numVertices; ++i) + { + if ((vertices[i].x >= box.min.x && vertices[i].x <= box.max.x) && + (vertices[i].y >= box.min.y && vertices[i].y <= box.max.y) && + (vertices[i].z >= box.min.z && vertices[i].z <= box.max.z)) + { + if (firstIntersection) + *firstIntersection = vertices[i]; + return TRUE; + } + } + + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingSphere &sphere, const Vector3 *vertices, int numVertices, Vector3 *firstIntersection) +{ + STACK_TRACE; + for (int i = 0; i < numVertices; ++i) + { + if (fabsf(Vector3::Distance(vertices[i], sphere.center)) < sphere.radius) + { + if (firstIntersection) + *firstIntersection = vertices[i]; + return TRUE; + } + } + + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingBox &a, const BoundingBox &b) +{ + STACK_TRACE; + if (a.max.x < b.min.x || a.min.x > b.max.x) + return FALSE; + if (a.max.y < b.min.y || a.min.y > b.max.y) + return FALSE; + if (a.max.z < b.min.z || a.min.z > b.max.z) + return FALSE; + + return TRUE; +} + +BOOL IntersectionTester::Test(const BoundingSphere &a, const BoundingSphere &b) +{ + STACK_TRACE; + Vector3 temp = a.center - b.center; + float distanceSquared = Vector3::Dot(temp, temp); + + float radiusSum = a.radius + b.radius; + if (distanceSquared <= radiusSum * radiusSum) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingSphere &sphere, const Plane &plane) +{ + STACK_TRACE; + float distance = Vector3::Dot(sphere.center, plane.normal) - plane.d; + if (fabsf(distance) <= sphere.radius) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const BoundingBox &box, const Plane &plane) +{ + STACK_TRACE; + Vector3 temp1 = (box.max + box.min) / 2.0f; + Vector3 temp2 = box.max - temp1; + + float radius = (temp2.x * fabsf(plane.normal.x)) + (temp2.y * fabsf(plane.normal.y)) + (temp2.z * fabsf(plane.normal.z)); + + float distance = Vector3::Dot(plane.normal, temp1) - plane.d; + + if (fabsf(distance) <= radius) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const Ray &ray, const Plane &plane, Vector3 *intersection) +{ + STACK_TRACE; + float denominator = Vector3::Dot(ray.direction, plane.normal); + if (denominator == 0.0f) + return FALSE; + + float t = ((-plane.d - Vector3::Dot(ray.position, plane.normal)) / denominator); + if (t < 0.0f) + return FALSE; + + if (intersection) + { + Vector3 temp1 = ray.GetPositionAt(t); + intersection->x = temp1.x; + intersection->y = temp1.y; + intersection->z = temp1.z; + } + + return TRUE; +} + +BOOL IntersectionTester::Test(const Ray &ray, const BoundingSphere &sphere, Vector3 *intersection) +{ + STACK_TRACE; + Vector3 temp1 = ray.position - sphere.center; + + float b = Vector3::Dot(temp1, ray.direction); + float c = Vector3::Dot(temp1, temp1) - (sphere.radius * sphere.radius); + + if (c > 0.0f && b > 0.0f) + return FALSE; + + float discriminant = b * b - c; + if (discriminant < 0.0f) + return FALSE; + + float t = -b - sqrtf(discriminant); + if (t < 0.0f) + t = 0.0f; + + if (intersection) + { + Vector3 temp2 = ray.GetPositionAt(t); + intersection->x = temp2.x; + intersection->y = temp2.y; + intersection->z = temp2.z; + } + + return TRUE; +} + +BOOL IntersectionTester::Test(const Ray &ray, const BoundingBox &box, Vector3 *intersection) +{ + STACK_TRACE; + float tmin = 0.0f; + float tmax = FLT_MAX; + + if (fabsf(ray.direction.x) < EPSILON) + { + if (ray.position.x < box.min.x || ray.position.x > box.max.x) + return FALSE; + } + else + { + float invD = 1.0f / ray.direction.x; + float t1 = (box.min.x - ray.position.x) * invD; + float t2 = (box.max.x - ray.position.x) * invD; + + if (t1 > t2) + { + float tswap = t1; + t1 = t2; + t2 = tswap; + } + + tmin = Max(tmin, t1); + tmax = Min(tmax, t2); + + if (tmin > tmax) + return FALSE; + } + + if (fabsf(ray.direction.y) < EPSILON) + { + if (ray.position.y < box.min.y || ray.position.y > box.max.y) + return FALSE; + } + else + { + float invD = 1.0f / ray.direction.y; + float t1 = (box.min.y - ray.position.y) * invD; + float t2 = (box.max.y - ray.position.y) * invD; + + if (t1 > t2) + { + float tswap = t1; + t1 = t2; + t2 = tswap; + } + + tmin = Max(tmin, t1); + tmax = Min(tmax, t2); + + if (tmin > tmax) + return FALSE; + } + + if (fabsf(ray.direction.z) < EPSILON) + { + if (ray.position.z < box.min.z || ray.position.z > box.max.z) + return FALSE; + } + else + { + float invD = 1.0f / ray.direction.z; + float t1 = (box.min.z - ray.position.z) * invD; + float t2 = (box.max.z - ray.position.z) * invD; + + if (t1 > t2) + { + float tswap = t1; + t1 = t2; + t2 = tswap; + } + + tmin = Max(tmin, t1); + tmax = Min(tmax, t2); + + if (tmin > tmax) + return FALSE; + } + + if (intersection) + { + Vector3 temp1 = ray.GetPositionAt(tmin); + intersection->x = temp1.x; + intersection->y = temp1.y; + intersection->z = temp1.z; + } + + return TRUE; +} + +BOOL IntersectionTester::Test(const BoundingBox &box, const BoundingSphere &sphere) +{ + STACK_TRACE; + float distanceSq = BoundingBox::GetSquaredDistanceFromPointToBox(sphere.center, box); + + if (distanceSq <= (sphere.radius * sphere.radius)) + return TRUE; + else + return FALSE; +} + +BOOL IntersectionTester::Test(const Ray &ray, const Vector3 &a, const Vector3 &b, const Vector3 &c, Vector3 *intersection) +{ + STACK_TRACE; + float r, num1, num2; + + Vector3 temp1 = Vector3::Cross(b - a, c - a); + if (temp1.x == 0.0f && temp1.y == 0.0f && temp1.z == 0.0f) + return FALSE; + + Vector3 temp2 = ray.position - a; + num1 = -Vector3::Dot(temp1, temp2); + num2 = Vector3::Dot(temp1, ray.direction); + if (fabsf(num2) < EPSILON) + { + if (num1 == 0.0f) + { + if (intersection) + *intersection = ray.position; + return TRUE; + } + else + return FALSE; + } + + r = num1 / num2; + if (r < 0.0f) + return FALSE; + + Vector3 temp3 = ray.GetPositionAt(r); + if (Vector3::IsPointInTriangle(temp3, a, b, c)) + { + if (intersection) + *intersection = temp3; + return TRUE; + } + else + return FALSE; +} + +BOOL IntersectionTester::Test(CollisionPacket &packet, const Vector3 &v1, const Vector3 &v2, const Vector3 &v3) +{ + STACK_TRACE; + BOOL foundCollision = FALSE; + + Vector3 p1 = v1 / packet.ellipsoidRadius; + Vector3 p2 = v2 / packet.ellipsoidRadius; + Vector3 p3 = v3 / packet.ellipsoidRadius; + + Plane trianglePlane(p1, p2, p3); + + // Is the triangle front-facing to the entity's velocity? + if (Plane::IsFrontFacingTo(trianglePlane, packet.esNormalizedVelocity)) + { + float t0; + float t1; + BOOL embeddedInPlane = FALSE; + float distToTrianglePlane = Plane::DistanceBetween(trianglePlane, packet.esPosition); + float normalDotVelocity = Vector3::Dot(trianglePlane.normal, packet.esVelocity); + + // Is the sphere travelling parallel to the plane? + if (normalDotVelocity == 0.0f) + { + if (fabsf(distToTrianglePlane) >= 1.0f) + { + // Sphere is not embedded in the plane, no collision possible + return FALSE; + } + else + { + // Sphere is embedded in the plane, it intersects throughout the whole time period + embeddedInPlane = TRUE; + t0 = 0.0f; + t1 = 1.0f; + } + } + else + { + // Not travelling parallel to the plane + t0 = (-1.0f - distToTrianglePlane) / normalDotVelocity; + t1 = (1.0f - distToTrianglePlane) / normalDotVelocity; + + // Swap so t0 < t1 + if (t0 > t1) + { + float temp = t1; + t1 = t0; + t0 = temp; + } + + // Check that at least one result is within range + if (t0 > 1.0f || t1 < 0.0f) + { + // Both values outside the range [0,1], no collision possible + return FALSE; + } + + t0 = Clamp(t0, 0.0f, 1.0f); + t1 = Clamp(t1, 0.0f, 1.0f); + } + + // At this point, we have two time values (t0, t1) between which the + // swept sphere intersects with the triangle plane + Vector3 collisionPoint; + float t = 1.0f; + + // First, check for a collision inside the triangle. This will happen + // at time t0 if at all as this is when the sphere rests on the front + // side of the triangle plane. + if (!embeddedInPlane) + { + Vector3 planeIntersectionPoint = (packet.esPosition - trianglePlane.normal) + packet.esVelocity * t0; + + if (Vector3::IsPointInTriangle(planeIntersectionPoint, p1, p2, p3)) + { + foundCollision = TRUE; + t = t0; + collisionPoint = planeIntersectionPoint; + } + } + + // If we haven't found a collision at this point, we need to check the + // points and edges of the triangle + if (foundCollision == FALSE) + { + Vector3 velocity = packet.esVelocity; + Vector3 base = packet.esPosition; + float velocitySquaredLength = Vector3::LengthSquared(velocity); + float a, b, c; + float newT; + + // For each vertex or edge, we have a quadratic equation to be solved + // Check against the points first + + a = velocitySquaredLength; + + // P1 + b = 2.0f * Vector3::Dot(velocity, base - p1); + c = Vector3::LengthSquared(p1 - base) - 1.0f; + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + t = newT; + foundCollision = TRUE; + collisionPoint = p1; + } + + // P2 + b = 2.0f * Vector3::Dot(velocity, base - p2); + c = Vector3::LengthSquared(p2 - base) - 1.0f; + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + t = newT; + foundCollision = TRUE; + collisionPoint = p2; + } + + // P3 + b = 2.0f * Vector3::Dot(velocity, base - p3); + c = Vector3::LengthSquared(p3 - base) - 1.0f; + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + t = newT; + foundCollision = TRUE; + collisionPoint = p3; + } + + // Now check against the edges + + // P1 -> P2 + Vector3 edge = p2 - p1; + Vector3 baseToVertex = p1 - base; + float edgeSquaredLength = Vector3::LengthSquared(edge); + float edgeDotVelocity = Vector3::Dot(edge, velocity); + float edgeDotBaseToVertex = Vector3::Dot(edge, baseToVertex); + + a = edgeSquaredLength * -velocitySquaredLength + edgeDotVelocity * edgeDotVelocity; + b = edgeSquaredLength * (2.0f * Vector3::Dot(velocity, baseToVertex)) - 2.0f * edgeDotVelocity * edgeDotBaseToVertex; + c = edgeSquaredLength * (1.0f - Vector3::LengthSquared(baseToVertex)) + edgeDotBaseToVertex * edgeDotBaseToVertex; + + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + // Check if intersection is within line segment + float f = (edgeDotVelocity * newT - edgeDotBaseToVertex) / edgeSquaredLength; + if (f >= 0.0f && f <= 1.0f) + { + // Intersection took place within the segment + t = newT; + foundCollision = TRUE; + collisionPoint = p1 + edge * f; + } + } + + // P2 -> P3 + edge = p3 - p2; + baseToVertex = p2 - base; + edgeSquaredLength = Vector3::LengthSquared(edge); + edgeDotVelocity = Vector3::Dot(edge, velocity); + edgeDotBaseToVertex = Vector3::Dot(edge, baseToVertex); + + a = edgeSquaredLength * -velocitySquaredLength + edgeDotVelocity * edgeDotVelocity; + b = edgeSquaredLength * (2.0f * Vector3::Dot(velocity, baseToVertex)) - 2.0f * edgeDotVelocity * edgeDotBaseToVertex; + c = edgeSquaredLength * (1.0f - Vector3::LengthSquared(baseToVertex)) + edgeDotBaseToVertex * edgeDotBaseToVertex; + + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + // Check if intersection is within line segment + float f = (edgeDotVelocity * newT - edgeDotBaseToVertex) / edgeSquaredLength; + if (f >= 0.0f && f <= 1.0f) + { + // Intersection took place within the segment + t = newT; + foundCollision = TRUE; + collisionPoint = p2 + edge * f; + } + } + + // P3 -> P1 + edge = p1 - p3; + baseToVertex = p3 - base; + edgeSquaredLength = Vector3::LengthSquared(edge); + edgeDotVelocity = Vector3::Dot(edge, velocity); + edgeDotBaseToVertex = Vector3::Dot(edge, baseToVertex); + + a = edgeSquaredLength * -velocitySquaredLength + edgeDotVelocity * edgeDotVelocity; + b = edgeSquaredLength * (2.0f * Vector3::Dot(velocity, baseToVertex)) - 2.0f * edgeDotVelocity * edgeDotBaseToVertex; + c = edgeSquaredLength * (1.0f - Vector3::LengthSquared(baseToVertex)) + edgeDotBaseToVertex * edgeDotBaseToVertex; + + if (GetLowestQuadraticRoot(a, b, c, t, newT)) + { + // Check if intersection is within line segment + float f = (edgeDotVelocity * newT - edgeDotBaseToVertex) / edgeSquaredLength; + if (f >= 0.0f && f <= 1.0f) + { + // Intersection took place within the segment + t = newT; + foundCollision = TRUE; + collisionPoint = p3 + edge * f; + } + } + } + + // Set result of test + if (foundCollision == TRUE) + { + float distanceToCollision = t * Vector3::Length(packet.esVelocity); + + // Does this triangle qualify for the closest collision? + if (packet.foundCollision == FALSE || distanceToCollision < packet.nearestDistance) + { + packet.nearestDistance = distanceToCollision; + packet.esIntersectionPoint = collisionPoint; + packet.foundCollision = TRUE; + } + } + } + + return foundCollision; +} + diff --git a/src/framework/math/intersectiontester.h b/src/framework/math/intersectiontester.h new file mode 100644 index 0000000..42c77b4 --- /dev/null +++ b/src/framework/math/intersectiontester.h @@ -0,0 +1,151 @@ +#ifndef __FRAMEWORK_MATH_INTERSECTIONTESTER_H_INCLUDED__ +#define __FRAMEWORK_MATH_INTERSECTIONTESTER_H_INCLUDED__ + +#include "../common.h" + +struct BoundingBox; +struct BoundingSphere; +struct CollisionPacket; +struct Plane; +struct Ray; +struct Vector3; + +/** + * Contains a number of utility methods for testing for collisions + * between basic geometric entities. + */ +class IntersectionTester +{ +public: + /** + * Tests for a collision between a box and a point. + * @param box the box to test + * @param point the point to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingBox &box, const Vector3 &point); + + /** + * Tests for a collision between a sphere and a point. + * @param sphere the sphere to test + * @param point the point to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingSphere &sphere, const Vector3 &point); + + /** + * Tests for a collision between a box and a set of points. + * @param box the box to test + * @param vertices an array of points + * @param numVertices the number of points in the array + * @param firstIntersection if not NULL, will contain the first intersection + * point if an intersection is found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingBox &box, const Vector3 *vertices, int numVertices, Vector3 *firstIntersection); + + /** + * Tests for a collision between a sphere and a set of points. + * @param sphere the sphere to test + * @param vertices an array of points + * @param numVertices the number of points in the array + * @param firstIntersection if not NULL, will contain the first intersection + * point if an intersection is found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingSphere &sphere, const Vector3 *vertices, int numVertices, Vector3 *firstIntersection); + + /** + * Tests for a collision between two boxes. + * @param a the first box to test + * @param b the second box to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingBox &a, const BoundingBox &b); + + /** + * Tests for a collision between two spheres. + * @param a the first sphere to test + * @param b the second sphere to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingSphere &a, const BoundingSphere &b); + + /** + * Tests for a collision between a sphere and a plane. + * @param sphere the sphere to test + * @param plane the plane to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingSphere &sphere, const Plane &plane); + + /** + * Tests for a collision between a box and a plane. + * @param box the box to test + * @param plane the plane to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingBox &box, const Plane &plane); + + /** + * Tests for a collision between a ray and a plane. + * @param ray the ray to test + * @param plane the plane to test + * @param intersection if not NULL, will contain the point of intersection + * if found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const Ray &ray, const Plane &plane, Vector3 *intersection); + + /** + * Tests for a collision between a ray and a sphere. + * @param ray the ray to test + * @param sphere the sphere to test + * @param intersection if not NULL, will contain the first point of intersection + * if found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const Ray &ray, const BoundingSphere &sphere, Vector3 *intersection); + + /** + * Tests for a collision between a ray and a box. + * @param ray the ray to test + * @param box the box to test + * @param intersection if not NULL, will contain the point of intersection + * if found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const Ray &ray, const BoundingBox &box, Vector3 *intersection); + + /** + * Tests for a collision between a box and a sphere. + * @param box the box to test + * @param sphere the sphere to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const BoundingBox &box, const BoundingSphere &sphere); + + /** + * Tests for a collision between a ray and a triangle. + * @param ray the ray to test + * @param a first point of the triangle to test + * @param b second point of the triangle to test + * @param c third point of the triangle to test + * @param intersection if not NULL, will contain the point of interestion + * if found at all + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(const Ray &ray, const Vector3 &a, const Vector3 &b, const Vector3 &c, Vector3 *intersection); + + /** + * Tests for collision between a "swept sphere" and a triangle. + * @param packet pre-filled packet containing details about the sphere to be tested + * @param v1 first point of the triangle to test + * @param v2 second point of the triangle to test + * @param v3 third point of the triangle to test + * @return BOOL TRUE if a collision is found, FALSE if not + */ + static BOOL Test(CollisionPacket &packet, const Vector3 &v1, const Vector3 &v2, const Vector3 &v3); +}; + +#endif diff --git a/src/framework/math/linesegment.h b/src/framework/math/linesegment.h new file mode 100644 index 0000000..842dfc8 --- /dev/null +++ b/src/framework/math/linesegment.h @@ -0,0 +1,84 @@ +#ifndef __FRAMEWORK_MATH_LINESEGMENT_H_INCLUDED__ +#define __FRAMEWORK_MATH_LINESEGMENT_H_INCLUDED__ + +#include "vector3.h" +#include "ray.h" + +/** + * Represents a line segment in 3D space. + */ +struct LineSegment +{ + /** + * Creates an uninitialized line segment. + */ + LineSegment(); + + /** + * Creates a line segment with the specified properties. + * @param a beginning of the line segment + * @param b ending of the line segment + */ + LineSegment(const Vector3 &a, const Vector3 &b); + + /** + * Creates a line segment with the specified properties. + * @param ax X coordinate of the beginning of the line segment + * @param ay Y coordinate of the beginning of the line segment + * @param az Z coordinate of the beginning of the line segment + * @param bx X coordinate of the ending of the line segment + * @param by Y coordinate of the ending of the line segment + * @param bz Z coordinate of the ending of the line segment + */ + LineSegment(float ax, float ay, float az, float bx, float by, float bz); + + /** + * Creates a line segment with the specified properties. + * @param ray a ray that this line segment will be based off of + * @param length the length from the origin of the ray that will be + * used to determine the end point of this line segment + */ + LineSegment(const Ray &ray, float length); + + /** + * Returns the direction the line segment is pointing if we assume + * that point "a" is the start position and "b" is the end position. + * @return Vector3 the direction that the line segment is pointing in + * (not a normalized vector) + */ + Vector3 GetDirection() const; + + Vector3 a; + Vector3 b; +}; + +inline LineSegment::LineSegment() +{ + a = ZERO_VECTOR; + b = ZERO_VECTOR; +} + +inline LineSegment::LineSegment(const Vector3 &a, const Vector3 &b) +{ + this->a = a; + this->b = b; +} + +inline LineSegment::LineSegment(float ax, float ay, float az, float bx, float by, float bz) +{ + this->a = Vector3(ax, ay, bz); + this->b = Vector3(bx, by, bz); +} + +inline LineSegment::LineSegment(const Ray &ray, float length) +{ + this->a = ray.position; + this->b = ray.GetPositionAt(length); +} + +inline Vector3 LineSegment::GetDirection() const +{ + return b - a; +} + +#endif diff --git a/src/framework/math/mathhelpers.cpp b/src/framework/math/mathhelpers.cpp new file mode 100644 index 0000000..1b2a289 --- /dev/null +++ b/src/framework/math/mathhelpers.cpp @@ -0,0 +1,130 @@ +#include "mathhelpers.h" + +#include "vector3.h" +#include + +void GetCartesianCoordsFromSpherical(float radius, float inclination, float azimuth, float &x, float &y, float &z) +{ + x = radius * sinf(inclination) * sinf(azimuth); + y = radius * cosf(inclination); + z = radius * sinf(inclination) * cosf(azimuth); +} + +Vector3 GetDirectionFromYAxisOrientation(float angle) +{ + Vector3 facing; + facing.y = 0.0f; + + // TODO: perhaps the whole "90 degree offset" thing we're doing below + // is too scenario-specific. maybe have an overload of this function + // which accepts an offset angle parameter? + // + // GetPointOnCircle() returns an angle based on a 2D cartesian grid where + // 0 degrees points in the +X direction. We want it to point in the + // +Y direction (2D cartesian Y = our 3D Z), so we offset our angle by 90 + // degrees before calling it to get the intended result + float adjustedAngle = RolloverClamp(angle - RADIANS_90, RADIANS_0, RADIANS_360); + GetPointOnCircle(1.0f, adjustedAngle, facing.x, facing.z); + + return facing; +} + +Vector3 GetDirectionFromAngles(float yaw, float pitch) +{ + Vector3 result; + result.x = cosf(yaw) * cosf(pitch); + result.y = sinf(yaw) * cosf(pitch); + result.z = sinf(pitch); + + return result; +} + +float GetAngleBetweenPoints(float x1, float y1, float x2, float y2) +{ + float angle = atan2f(y2 - y1, x2 - x1); + + // we offset the angle by 90 degrees to ensure 0 degrees points in the + // +Y direction on a 2D cartesian grid instead of +X. This corresponds with + // the rest of our direction coordinate system. + return angle - RADIANS_90; +} + +BOOL GetLowestQuadraticRoot(float a, float b, float c, float maxR, float &root) +{ + float determinant = (b * b) - (4.0f * a * c); + + // If the determinant is negative, there is no solution (can't square root a negative) + if (determinant < 0.0f) + return FALSE; + + float sqrtDeterminant = sqrtf(determinant); + float root1 = (-b - sqrtDeterminant) / (2 * a); + float root2 = (-b + sqrtDeterminant) / (2 * a); + // Sort so root1 <= root2 + if (root1 > root2) + { + float temp = root2; + root2 = root1; + root1 = temp; + } + + // Get the lowest root + if (root1 > 0 && root1 < maxR) + { + root = root1; + return TRUE; + } + + if (root2 > 0 && root2 < maxR) + { + root = root2; + return TRUE; + } + + // No valid solutions found + return FALSE; +} + +void GetPointOnCircle(float radius, float angle, float &x, float &y) +{ + x = radius * cosf(angle); + y = radius * sinf(angle); +} + +uint32_t GetNextPowerOf2(uint32_t n) +{ + uint32_t i = n & (~n + 1); + while (i < n) + i <<= 1; + + return i; +} + +template <> +float Sign(const float &value) +{ + if (value < 0.0f) + return -1.0f; + else if (value > 0.0f) + return 1.0f; + else + return 0.0f; +} + +template <> +float RolloverClamp(const float &value, const float &low, const float &high) +{ + float temp = value; + do + { + float range = fabsf(high - low); + if (temp < low) + temp = temp + range; + if (value > high) + temp = temp - range; + } + while (temp < low || temp > high); // loop through as many times as necessary to put the value within the low/high range + + return temp; +} + diff --git a/src/framework/math/mathhelpers.h b/src/framework/math/mathhelpers.h new file mode 100644 index 0000000..e490d90 --- /dev/null +++ b/src/framework/math/mathhelpers.h @@ -0,0 +1,293 @@ +#ifndef __FRAMEWORK_MATH_MATHHELPERS_H_INCLUDED__ +#define __FRAMEWORK_MATH_MATHHELPERS_H_INCLUDED__ + +#include "../common.h" +#include "common.h" + +#include +#include +#include + +struct Vector3; + +#ifdef _MSC_VER +#include +#ifndef INFINITY +#define INFINITY (std::numeric_limits::infinity()) +#endif +#endif + +#ifdef _MSC_VER +#define isnan(x) _isnan(x) +#endif + +/** + * Converts coordinates from spherical to cartesian. + * @param radius distance from the origin "O" to the point "P" (the "r" value) + * @param inclination the angle (in radians) between the zenith direction + * and the line segment OP (the "theta" value) + * @param azimuth the signed angle (in radians) measured from the azimuth + * reference direction to the orthogonal projection of the + * line segment OP on the reference plane (the "phi" value) + * @param x variable to hold the output X cartesian coordinate + * @param y variable to hold the output Y cartesian coordinate + * @param z variable to hold the output Z cartesian coordinate + */ +void GetCartesianCoordsFromSpherical(float radius, float angleTheta, float angleRho, float &x, float &y, float &z); + +/** + * Converts an angle around the Y axis to a direction vector that + * lies flat on the XZ plane. Note that the angle is offset so that 0 degrees + * points directly down the +Y axis on a 2D cartesian grid, instead of the +X + * axis as one might expect. + * @param angle the Y axis angle (in radians) + * @return Vector3 direction vector on the XZ plane + */ +Vector3 GetDirectionFromYAxisOrientation(float angle); + +/** + * Converts euler angles to an equivalent direction vector. Note that this just + * uses one of many other ways to do this (the others using any other rotation + * order). + * @param yaw the yaw rotation angle (in radians) + * @param pitch the pitch rotation angle (in radians) + * @return Vector3 direction vector + */ +Vector3 GetDirectionFromAngles(float yaw, float pitch); + +/** + * Returns the angle between two 2D points. Note that the returned angle is + * offset so that 0 degrees points directly down the +Y axis on a 2D cartesian + * grid, instead of the +X axis as one might expect. + * @param x1 X coordinate of the first point + * @param y1 Y coordinate of the first point + * @param x2 X coordinate of the second point + * @param y2 Y coordinate of the second point + * @return float the angle (in radians) between the two points + */ +float GetAngleBetweenPoints(float x1, float y1, float x2, float y2); + +/** + * Solves a quadratic equation and returns the lowest root. + * @param a the value of the a variable in the quadratic equation + * @param b the value of the b variable in the quadratic equation + * @param c the value of the c variable in the quadratic equation + * @param maxR the maximum root value we will accept as an answer. + anything that is higher will not be accepted as a solution + * @param root the variable to hold the lowest root value if one is found + * @return BOOL TRUE if the quadratic could be solved, FALSE if not + */ +BOOL GetLowestQuadraticRoot(float a, float b, float c, float maxR, float &root); + +/** + * Gets the power of two value that comes after the given value. + * @param n minimum value for which we want to get the power of two after + * @return uint32_t the first power of two that comes after n + */ +uint32_t GetNextPowerOf2(uint32_t n); + +/** + * Returns the 2D point on a circle's circumference given a radius and angle. + * @param radius the radius of the circle + * @param angle the angle around the circle (in radians) + * @param x the variable to hold the X point on the circle's circumference + * @param y the variable to hold the Y point on the circle's circumference + */ +void GetPointOnCircle(float radius, float angle, float &x, float &y); + +/** + * Clamps a value to a given range. + * @param value the value to be clamped + * @param low the low end of the range to clamp to + * @param high the high end of the range to clamp to + * @return T the clamped value + */ +template +inline T Clamp(const T &value, const T &low, const T &high) +{ + if (value < low) + return low; + if (value > high) + return high; + + return value; +} + +/** + * Converts degrees to radians. + * @param degrees degree value to convert + * @return float equivalent value in radians + */ +inline float DegreesToRadians(float degrees) +{ + return degrees * PI_OVER_180; +} + +/** + * Checks two floats for equality using a defined "tolerance" to account + * for floating point rounding errors, etc. + * @param a first value to check + * @param b second value to check + * @param tolerance tolerance value to use (e.g. FLT_EPSILON) + * @return BOOL TRUE if equal, FALSE if not + */ +inline BOOL IsCloseEnough(float a, float b, float tolerance = TOLERANCE) +{ + return fabsf((a - b) / ((b == 0.0f) ? 1.0f : b)) < tolerance; +} + +/** + * Determines if a given number is a power of two. + * @param n number to check + * @return BOOL TRUE if a power of two, FALSE if not + */ +inline BOOL IsPowerOf2(int32_t n) +{ + return (n != 0) && !(n & (n - 1)); +} + +/** + * Linearly interpolates between two values. + * @param a first value (low end of range) + * @param b second value (high end of range) + * @param t the amount to interpolate between the two values + * @return T the interpolated value + */ +template +inline T Lerp(const T &a, const T &b, const T &t) +{ + return a + (b - a) * t; +} + +/** + * Given a linearly interpolated value and the original range (high and + * low) of the linear interpolation, this will determine what the original + * 0.0 to 1.0 value (weight) was used to perform the interpolation. + * @param a first value (low end of range) + * @param b second value (high end of range) + * @param lerpValue the result of the original interpolation + * @return T the interpolation value (weight, in the range 0.0 to 1.0) + * used in the original interpolation + */ +template +inline T InverseLerp(const T &a, const T &b, const T &lerpValue) +{ + return (lerpValue - a) / (b - a); +} + +/** + * Converts radians to degrees. + * @param radians radian value to convert + * @return float equivalent value in degrees + */ +inline float RadiansToDegrees(float radians) +{ + return radians * (1.0f / PI_OVER_180); +} + +/** + * Clamps a value to a given range, but if the value is outside the range + * instead of returning the low/high end of the range, this will continue + * counting after moving to the opposite end of the range to arrive at a + * final value. + * @param value the value to be clamped + * @param low the low end of the range to clamp to + * @param high the high end of the range to clamp to + * @return T the clamped value + */ +template +inline T RolloverClamp(const T &value, const T &low, const T &high) +{ + T temp = value; + do + { + float range = abs(high - low); + if (temp < low) + temp = temp + range; + if (value > high) + temp = temp - range; + } + while (temp < low || temp > high); // loop through as many times as necessary to put the value within the low/high range + + return temp; +} + +template <> float RolloverClamp(const float &value, const float &low, const float &high); + +/** + * Rounds a value to the nearest whole number. Will round up if the + * fractional part of the value is greater then or equal to 0.5. + * @param value the value to round + * @return float the rounded value + */ +inline float Round(float value) +{ + return ceilf(value + 0.5f); +} + +/** + * Re-scales a given value from an old min/max range to a new and + * different min/max range such that the value is approximately + * at the same distance between both min and max values. + * @param value the value to be rescaled which is currently between + * originalMin and originalMax + * @param originalMin original min value (low end of range) + * @param originalMax original max value (high end of range) + * @param newMin new min value (low end of range) + * @param newMax new max value (high end of range) + * @return T re-scaled value which will fall between newMin and newMax + */ +template +inline T ScaleRange(const T &value, const T &originalMin, const T &originalMax, const T &newMin, const T &newMax) +{ + return (value / ((originalMax - originalMin) / (newMax - newMin))) + newMin; +} + +/** + * Returns the sign of the given value. + * @param value value to get the sign of + * @return T the sign of the given value + */ +template +inline T Sign(const T &value) +{ + if (value < 0) + return -1; + else if (value > 0) + return 1; + else + return 0; +} + +template <> float Sign(const float &value); + +/** + * Interpolates between two values using a cubic equation. + * @param low low end of range to interpolate between + * @param high high end of range to interpolate between + * @param t amount to interpolate by (the weight) + * @return float the interpolated value + */ +inline float SmoothStep(float low, float high, float t) +{ + float n = Clamp(t, 0.0f, 1.0f); + return Lerp(low, high, (n * n) * (3.0f - (2.0f * n))); +} + +/** + * Rounds a value to the nearest whole number. If the value has a + * fractional component that will be used to either round up or down. + * If the value is negative, this will round down. + * @param value the value to round + * @return float the rounded value + */ +inline float SymmetricalRound(float value) +{ + if (value > 0.0f) + return floorf(value + 0.5f); + else + return ceilf(value - 0.5f); +} + +#endif + diff --git a/src/framework/math/matrix3x3.h b/src/framework/math/matrix3x3.h new file mode 100644 index 0000000..1429c4a --- /dev/null +++ b/src/framework/math/matrix3x3.h @@ -0,0 +1,605 @@ +#ifndef __FRAMEWORK_MATH_MATRIX3X3_H_INCLUDED__ +#define __FRAMEWORK_MATH_MATRIX3X3_H_INCLUDED__ + +#include "../common.h" +#include +#include "common.h" +#include "mathhelpers.h" +#include "vector3.h" +#include "matrix4x4.h" + +enum MATRIX3X3_ELEMENTS +{ + M3X3_11 = 0, + M3X3_12 = 3, + M3X3_13 = 6, + M3X3_21 = 1, + M3X3_22 = 4, + M3X3_23 = 7, + M3X3_31 = 2, + M3X3_32 = 5, + M3X3_33 = 8 +}; + +/** + * Represents a 3x3 column-major Matrix and provides common methods for + * matrix math. + *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • http://www.dhpoware.com/source/mathlib.html
    • + *
  • http://www.songho.ca/opengl/gl_transform.html
    • + *
  • http://www.opengl.org/sdk/docs/man/
    • + *
+ */ +struct Matrix3x3 +{ + /** + * Creates an uninitialized matrix. + */ + Matrix3x3(); + + /** + * Creates a matrix with the specified elements. + */ + Matrix3x3( + float m11, float m12, float m13, + float m21, float m22, float m23, + float m31, float m32, float m33 + ); + + /** + * Creates a matrix with the specified elements. + * @param mv an array of 9 values that will be used as this matrix's + * elements + */ + Matrix3x3(const float *mv); + + /** + * Creates a matrix from a 4x4 one. + * @param m the 4x4 matrix to create this matrix from (top-left 3x3 elements + * will be copied into this one) + */ + Matrix3x3(const Matrix4x4 &m); + + /** + * Sets new element values for this matrix. + */ + void Set( + float m11, float m12, float m13, + float m21, float m22, float m23, + float m31, float m32, float m33 + ); + + /** + * @return the determinant of this matrix + */ + float GetDeterminant() const; + + /** + * @return the forward vector (z-axis) + */ + Vector3 GetForward() const; + + /** + * @return the backward vector (inverse z-axis) + */ + Vector3 GetBackward() const; + + /** + * @return the left vector (x-axis) + */ + Vector3 GetLeft() const; + + /** + * @return the right vector (inverse x-axis) + */ + Vector3 GetRight() const; + + /** + * @return the up vector (y-axis) + */ + Vector3 GetUp() const; + + /** + * @return the down vector (inverse y-axis) + */ + Vector3 GetDown() const; + + /** + * @return an equivalent 4x4 matrix + */ + Matrix4x4 To4x4() const; + + /** + * @return identity matrix + */ + static Matrix3x3 Identity(); + + /** + * Constructs a rotation matrix from Euler angles. + * @param x the x angle (in radians) + * @param y the y angle (in radians) + * @param z the z angle (in radians) + * @return a rotation matrix representing the provided angles + */ + static Matrix3x3 CreateFromEulerAngles(float x, float y, float z); + + /** + * Sets up a rotation matrix about the specified axis. This returns a matrix + * equivalent to the matrix that OpenGL multiples into the modelview matrix + * whenever glRotate(angle, axis.x, axis.y, axis.z) is called. + * @param angle the angle to rotate by (in radians) + * @param axis unit vector denoting the axis for the rotation + * @return a rotation matrix representing the specific axis rotation + */ + static Matrix3x3 CreateRotation(float angle, const Vector3 &axis); + + /** + * Constructs a rotation matrix for a rotation around the x axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 1.0f, 0.0f, 0.0f) is called. + * @param angle angle to rotate the x axis around (in radians) + * @return the rotation matrix + */ + static Matrix3x3 CreateRotationX(float angle); + + /** + * Constructs a rotation matrix for a rotation around the y axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 0.0f, 1.0f, 0.0f) is called. + * @param angle angle to rotate the y axis around (in radians) + * @return the rotation matrix + */ + static Matrix3x3 CreateRotationY(float angle); + + /** + * Constructs a rotation matrix for a rotation around the z axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 0.0f, 0.0f, 1.0f) is called. + * @param angle angle to rotate the z axis around (in radians) + * @return the rotation matrix + */ + static Matrix3x3 CreateRotationZ(float angle); + + /** + * Calculates the inverse of the specified matrix. + * @param m the matrix to calculate the inverse of + * @return the inverse of the specified matrix + */ + static Matrix3x3 Inverse(const Matrix3x3 &m); + + /** + * Calculates the transpose of a given matrix. + * @param m the matrix to get the transpose of + * @return the transpose matrix + */ + static Matrix3x3 Transpose(const Matrix3x3 &m); + + /** + * Transforms the given vertex by a matrix. + * @param m the transformation matrix to use + * @param v the vertex to be transformed + * @return the transformed vertex + */ + static Vector3 Transform(const Matrix3x3 &m, const Vector3 &v); + + float m[9]; +}; + +Matrix3x3 operator+(const Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 &operator+=(Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 operator-(const Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 &operator-=(Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 operator*(const Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 &operator*=(Matrix3x3 &left, const Matrix3x3 &right); +Matrix3x3 operator*(const Matrix3x3 &left, float right); +Matrix3x3 &operator*=(Matrix3x3 &left, float right); +Vector3 operator*(const Vector3 &left, const Matrix3x3 &right); + +#define IDENTITY_MATRIX3X3 Matrix3x3::Identity() + +inline Matrix3x3::Matrix3x3() +{ +} + +inline Matrix3x3::Matrix3x3( + float m11, float m12, float m13, + float m21, float m22, float m23, + float m31, float m32, float m33 + ) +{ + m[M3X3_11] = m11; + m[M3X3_12] = m12; + m[M3X3_13] = m13; + m[M3X3_21] = m21; + m[M3X3_22] = m22; + m[M3X3_23] = m23; + m[M3X3_31] = m31; + m[M3X3_32] = m32; + m[M3X3_33] = m33; +} + +inline Matrix3x3::Matrix3x3(const float *mv) +{ + m[M3X3_11] = mv[M3X3_11]; + m[M3X3_12] = mv[M3X3_12]; + m[M3X3_13] = mv[M3X3_13]; + m[M3X3_21] = mv[M3X3_21]; + m[M3X3_22] = mv[M3X3_22]; + m[M3X3_23] = mv[M3X3_23]; + m[M3X3_31] = mv[M3X3_31]; + m[M3X3_32] = mv[M3X3_32]; + m[M3X3_33] = mv[M3X3_33]; +} + +inline Matrix3x3::Matrix3x3(const Matrix4x4 &m) +{ + this->m[M3X3_11] = m.m[_11]; + this->m[M3X3_12] = m.m[_12]; + this->m[M3X3_13] = m.m[_13]; + this->m[M3X3_21] = m.m[_21]; + this->m[M3X3_22] = m.m[_22]; + this->m[M3X3_23] = m.m[_23]; + this->m[M3X3_31] = m.m[_31]; + this->m[M3X3_32] = m.m[_32]; + this->m[M3X3_33] = m.m[_33]; +} + +inline void Matrix3x3::Set( + float m11, float m12, float m13, + float m21, float m22, float m23, + float m31, float m32, float m33 + ) +{ + m[M3X3_11] = m11; + m[M3X3_12] = m12; + m[M3X3_13] = m13; + m[M3X3_21] = m21; + m[M3X3_22] = m22; + m[M3X3_23] = m23; + m[M3X3_31] = m31; + m[M3X3_32] = m32; + m[M3X3_33] = m33; +} + +inline float Matrix3x3::GetDeterminant() const +{ + return + m[M3X3_11] * m[M3X3_22] * m[M3X3_33] + + m[M3X3_12] * m[M3X3_23] * m[M3X3_31] + + m[M3X3_13] * m[M3X3_21] * m[M3X3_32] - + m[M3X3_11] * m[M3X3_23] * m[M3X3_32] - + m[M3X3_12] * m[M3X3_21] * m[M3X3_33] - + m[M3X3_13] * m[M3X3_22] * m[M3X3_31]; +} + +inline Vector3 Matrix3x3::GetForward() const +{ + return Vector3(m[M3X3_13], m[M3X3_23], m[M3X3_33]); +} + +inline Vector3 Matrix3x3::GetBackward() const +{ + return Vector3(-m[M3X3_13], -m[M3X3_23], -m[M3X3_33]); +} + +inline Vector3 Matrix3x3::GetLeft() const +{ + return Vector3(m[M3X3_11], m[M3X3_21], m[M3X3_31]); +} + +inline Vector3 Matrix3x3::GetRight() const +{ + return Vector3(-m[M3X3_11], -m[M3X3_21], -m[M3X3_31]); +} + +inline Vector3 Matrix3x3::GetUp() const +{ + return Vector3(m[M3X3_12], m[M3X3_22], m[M3X3_32]); +} + +inline Vector3 Matrix3x3::GetDown() const +{ + return Vector3(-m[M3X3_12], -m[M3X3_22], -m[M3X3_32]); +} + +inline Matrix4x4 Matrix3x3::To4x4() const +{ + Matrix4x4 out; + + out.m[_11] = m[M3X3_11]; + out.m[_12] = m[M3X3_12]; + out.m[_13] = m[M3X3_13]; + out.m[_14] = 0.0f; + + out.m[_21] = m[M3X3_21]; + out.m[_22] = m[M3X3_22]; + out.m[_23] = m[M3X3_23]; + out.m[_24] = 0.0f; + + out.m[_31] = m[M3X3_31]; + out.m[_32] = m[M3X3_32]; + out.m[_33] = m[M3X3_33]; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix3x3 Matrix3x3::Identity() +{ + Matrix3x3 identity; + + identity.m[M3X3_11] = 1.0f; + identity.m[M3X3_12] = 0.0f; + identity.m[M3X3_13] = 0.0f; + identity.m[M3X3_21] = 0.0f; + identity.m[M3X3_22] = 1.0f; + identity.m[M3X3_23] = 0.0f; + identity.m[M3X3_31] = 0.0f; + identity.m[M3X3_32] = 0.0f; + identity.m[M3X3_33] = 1.0f; + + return identity; +} + +inline Matrix3x3 Matrix3x3::CreateFromEulerAngles(float x, float y, float z) +{ + Matrix3x3 rotateZ = CreateRotationZ(z); + Matrix3x3 rotateY = CreateRotationY(y); + Matrix3x3 rotateX = CreateRotationX(x); + + // "right-to-left" column-major matrix concatenation + return rotateZ * rotateY * rotateX; +} + + +inline Matrix3x3 Matrix3x3::CreateRotation(float angle, const Vector3 &axis) +{ + Matrix3x3 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[M3X3_11] = (axis.x * axis.x) * (1.0f - c) + c; + out.m[M3X3_12] = (axis.x * axis.y) * (1.0f - c) - (axis.z * s); + out.m[M3X3_13] = (axis.x * axis.z) * (1.0f - c) + (axis.y * s); + + out.m[M3X3_21] = (axis.y * axis.x) * (1.0f - c) + (axis.z * s); + out.m[M3X3_22] = (axis.y * axis.y) * (1.0f - c) + c; + out.m[M3X3_23] = (axis.y * axis.z) * (1.0f - c) - (axis.x * s); + + out.m[M3X3_31] = (axis.z * axis.x) * (1.0f - c) - (axis.y * s); + out.m[M3X3_32] = (axis.z * axis.y) * (1.0f - c) + (axis.x * s); + out.m[M3X3_33] = (axis.z * axis.z) * (1.0f - c) + c; + + return out; +} + +inline Matrix3x3 Matrix3x3::CreateRotationX(float angle) +{ + Matrix3x3 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[M3X3_11] = 1.0f; + out.m[M3X3_12] = 0.0f; + out.m[M3X3_13] = 0.0f; + + out.m[M3X3_21] = 0.0f; + out.m[M3X3_22] = c; + out.m[M3X3_23] = -s; + + out.m[M3X3_31] = 0.0f; + out.m[M3X3_32] = s; + out.m[M3X3_33] = c; + + return out; +} + +inline Matrix3x3 Matrix3x3::CreateRotationY(float angle) +{ + Matrix3x3 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[M3X3_11] = c; + out.m[M3X3_12] = 0.0f; + out.m[M3X3_13] = s; + + out.m[M3X3_21] = 0.0f; + out.m[M3X3_22] = 1.0f; + out.m[M3X3_23] = 0.0f; + + out.m[M3X3_31] = -s; + out.m[M3X3_32] = 0.0f; + out.m[M3X3_33] = c; + + return out; +} + +inline Matrix3x3 Matrix3x3::CreateRotationZ(float angle) +{ + Matrix3x3 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[M3X3_11] = c; + out.m[M3X3_12] = -s; + out.m[M3X3_13] = 0.0f; + + out.m[M3X3_21] = s; + out.m[M3X3_22] = c; + out.m[M3X3_23] = 0.0f; + + out.m[M3X3_31] = 0.0f; + out.m[M3X3_32] = 0.0f; + out.m[M3X3_33] = 1.0f; + + return out; +} + +inline Matrix3x3 Matrix3x3::Inverse(const Matrix3x3 &m) +{ + float d = m.GetDeterminant(); + if (IsCloseEnough(d, 0.0f)) + return IDENTITY_MATRIX3X3; + else + { + Matrix3x3 out; + + d = 1.0f / d; + + out.m[M3X3_11] = d * (m.m[M3X3_22] * m.m[M3X3_33] - m.m[M3X3_32] * m.m[M3X3_23]); + out.m[M3X3_21] = d * (m.m[M3X3_31] * m.m[M3X3_23] - m.m[M3X3_21] * m.m[M3X3_33]); + out.m[M3X3_31] = d * (m.m[M3X3_21] * m.m[M3X3_32] - m.m[M3X3_31] * m.m[M3X3_22]); + out.m[M3X3_12] = d * (m.m[M3X3_32] * m.m[M3X3_13] - m.m[M3X3_12] * m.m[M3X3_33]); + out.m[M3X3_22] = d * (m.m[M3X3_11] * m.m[M3X3_33] - m.m[M3X3_31] * m.m[M3X3_13]); + out.m[M3X3_32] = d * (m.m[M3X3_31] * m.m[M3X3_12] - m.m[M3X3_11] * m.m[M3X3_32]); + out.m[M3X3_13] = d * (m.m[M3X3_12] * m.m[M3X3_23] - m.m[M3X3_22] * m.m[M3X3_13]); + out.m[M3X3_23] = d * (m.m[M3X3_21] * m.m[M3X3_13] - m.m[M3X3_11] * m.m[M3X3_23]); + out.m[M3X3_33] = d * (m.m[M3X3_11] * m.m[M3X3_22] - m.m[M3X3_21] * m.m[M3X3_12]); + + return out; + } +} + +inline Matrix3x3 Matrix3x3::Transpose(const Matrix3x3 &m) +{ + Matrix3x3 out; + + out.m[M3X3_11] = m.m[M3X3_11]; + out.m[M3X3_12] = m.m[M3X3_21]; + out.m[M3X3_13] = m.m[M3X3_31]; + + out.m[M3X3_21] = m.m[M3X3_12]; + out.m[M3X3_22] = m.m[M3X3_22]; + out.m[M3X3_23] = m.m[M3X3_32]; + + out.m[M3X3_31] = m.m[M3X3_13]; + out.m[M3X3_32] = m.m[M3X3_23]; + out.m[M3X3_33] = m.m[M3X3_33]; + + return out; +} + +inline Vector3 Matrix3x3::Transform(const Matrix3x3 &m, const Vector3 &v) +{ + Vector3 out; + + out.x = v.x * m.m[M3X3_11] + v.y * m.m[M3X3_12] + v.z * m.m[M3X3_13]; + out.y = v.x * m.m[M3X3_21] + v.y * m.m[M3X3_22] + v.z * m.m[M3X3_23]; + out.z = v.x * m.m[M3X3_31] + v.y * m.m[M3X3_32] + v.z * m.m[M3X3_33]; + + return out; +} + +inline Matrix3x3 operator+(const Matrix3x3 &left, const Matrix3x3 &right) +{ + Matrix3x3 result; + + result.m[M3X3_11] = left.m[M3X3_11] + right.m[M3X3_11]; + result.m[M3X3_12] = left.m[M3X3_12] + right.m[M3X3_12]; + result.m[M3X3_13] = left.m[M3X3_13] + right.m[M3X3_13]; + result.m[M3X3_21] = left.m[M3X3_21] + right.m[M3X3_21]; + result.m[M3X3_22] = left.m[M3X3_22] + right.m[M3X3_22]; + result.m[M3X3_23] = left.m[M3X3_23] + right.m[M3X3_23]; + result.m[M3X3_31] = left.m[M3X3_31] + right.m[M3X3_31]; + result.m[M3X3_32] = left.m[M3X3_32] + right.m[M3X3_32]; + result.m[M3X3_33] = left.m[M3X3_33] + right.m[M3X3_33]; + + return result; +} + +inline Matrix3x3 &operator+=(Matrix3x3 &left, const Matrix3x3 &right) +{ + left = left + right; + return left; +} + +inline Matrix3x3 operator-(const Matrix3x3 &left, const Matrix3x3 &right) +{ + Matrix3x3 result; + + result.m[M3X3_11] = left.m[M3X3_11] - right.m[M3X3_11]; + result.m[M3X3_12] = left.m[M3X3_12] - right.m[M3X3_12]; + result.m[M3X3_13] = left.m[M3X3_13] - right.m[M3X3_13]; + result.m[M3X3_21] = left.m[M3X3_21] - right.m[M3X3_21]; + result.m[M3X3_22] = left.m[M3X3_22] - right.m[M3X3_22]; + result.m[M3X3_23] = left.m[M3X3_23] - right.m[M3X3_23]; + result.m[M3X3_31] = left.m[M3X3_31] - right.m[M3X3_31]; + result.m[M3X3_32] = left.m[M3X3_32] - right.m[M3X3_32]; + result.m[M3X3_33] = left.m[M3X3_33] - right.m[M3X3_33]; + + return result; +} + +inline Matrix3x3 &operator-=(Matrix3x3 &left, const Matrix3x3 &right) +{ + left = left - right; + return left; +} + +inline Matrix3x3 operator*(const Matrix3x3 &left, const Matrix3x3 &right) +{ + Matrix3x3 result; + + result.m[M3X3_11] = left.m[M3X3_11] * right.m[M3X3_11] + left.m[M3X3_12] * right.m[M3X3_21] + left.m[M3X3_13] * right.m[M3X3_31]; + result.m[M3X3_12] = left.m[M3X3_11] * right.m[M3X3_12] + left.m[M3X3_12] * right.m[M3X3_22] + left.m[M3X3_13] * right.m[M3X3_32]; + result.m[M3X3_13] = left.m[M3X3_11] * right.m[M3X3_13] + left.m[M3X3_12] * right.m[M3X3_23] + left.m[M3X3_13] * right.m[M3X3_33]; + + result.m[M3X3_21] = left.m[M3X3_21] * right.m[M3X3_11] + left.m[M3X3_22] * right.m[M3X3_21] + left.m[M3X3_23] * right.m[M3X3_31]; + result.m[M3X3_22] = left.m[M3X3_21] * right.m[M3X3_12] + left.m[M3X3_22] * right.m[M3X3_22] + left.m[M3X3_23] * right.m[M3X3_32]; + result.m[M3X3_23] = left.m[M3X3_21] * right.m[M3X3_13] + left.m[M3X3_22] * right.m[M3X3_23] + left.m[M3X3_23] * right.m[M3X3_33]; + + result.m[M3X3_31] = left.m[M3X3_31] * right.m[M3X3_11] + left.m[M3X3_32] * right.m[M3X3_21] + left.m[M3X3_33] * right.m[M3X3_31]; + result.m[M3X3_32] = left.m[M3X3_31] * right.m[M3X3_12] + left.m[M3X3_32] * right.m[M3X3_22] + left.m[M3X3_33] * right.m[M3X3_32]; + result.m[M3X3_33] = left.m[M3X3_31] * right.m[M3X3_13] + left.m[M3X3_32] * right.m[M3X3_23] + left.m[M3X3_33] * right.m[M3X3_33]; + + return result; +} + +inline Matrix3x3 &operator*=(Matrix3x3 &left, const Matrix3x3 &right) +{ + left = left * right; + return left; +} + +inline Matrix3x3 operator*(const Matrix3x3 &left, float right) +{ + Matrix3x3 result; + + result.m[M3X3_11] = left.m[M3X3_11] * right; + result.m[M3X3_12] = left.m[M3X3_12] * right; + result.m[M3X3_13] = left.m[M3X3_13] * right; + result.m[M3X3_21] = left.m[M3X3_21] * right; + result.m[M3X3_22] = left.m[M3X3_22] * right; + result.m[M3X3_23] = left.m[M3X3_23] * right; + result.m[M3X3_31] = left.m[M3X3_31] * right; + result.m[M3X3_32] = left.m[M3X3_32] * right; + result.m[M3X3_33] = left.m[M3X3_33] * right; + + return result; +} + +inline Matrix3x3 &operator*=(Matrix3x3 &left, float right) +{ + left = left * right; + return left; +} + +inline Vector3 operator*(const Vector3 &left, const Matrix3x3 &right) +{ + return Matrix3x3::Transform(right, left); +} + +#endif + diff --git a/src/framework/math/matrix4x4.h b/src/framework/math/matrix4x4.h new file mode 100644 index 0000000..f45bd17 --- /dev/null +++ b/src/framework/math/matrix4x4.h @@ -0,0 +1,1311 @@ +#ifndef __FRAMEWORK_MATH_MATRIX4X4_H_INCLUDED__ +#define __FRAMEWORK_MATH_MATRIX4X4_H_INCLUDED__ + +#include "../common.h" +#include +#include "common.h" +#include "mathhelpers.h" +#include "vector3.h" +#include "vector4.h" + +enum MATRIX_ELEMENTS +{ + _11 = 0, + _12 = 4, + _13 = 8, + _14 = 12, + _21 = 1, + _22 = 5, + _23 = 9, + _24 = 13, + _31 = 2, + _32 = 6, + _33 = 10, + _34 = 14, + _41 = 3, + _42 = 7, + _43 = 11, + _44 = 15 +}; + +/** + * Represents a 4x4 column-major Matrix and provides common methods for + * matrix math. + *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • http://www.dhpoware.com/source/mathlib.html
    • + *
  • http://www.songho.ca/opengl/gl_transform.html
    • + *
  • http://www.opengl.org/sdk/docs/man/
    • + *
+ */ +struct Matrix4x4 +{ + /** + * Creates an uninitialized matrix. + */ + Matrix4x4(); + + /** + * Creates a matrix with the specified elements. + */ + Matrix4x4( + float m11, float m12, float m13, float m14, + float m21, float m22, float m23, float m24, + float m31, float m32, float m33, float m34, + float m41, float m42, float m43, float m44 + ); + + /** + * Creates a matrix with the specified elements. + * @param mv an array of 16 values that will be used as this matrix's + * elements + */ + Matrix4x4(const float *mv); + + /** + * Sets new element values for this matrix. + */ + void Set( + float m11, float m12, float m13, float m14, + float m21, float m22, float m23, float m24, + float m31, float m32, float m33, float m34, + float m41, float m42, float m43, float m44 + ); + + /** + * @return the determinant of this matrix + */ + float GetDeterminant() const; + + /** + * @return the forward vector (z-axis) + */ + Vector3 GetForward() const; + + /** + * @return the backward vector (inverse z-axis) + */ + Vector3 GetBackward() const; + + /** + * @return the left vector (x-axis) + */ + Vector3 GetLeft() const; + + /** + * @return the right vector (inverse x-axis) + */ + Vector3 GetRight() const; + + /** + * @return the up vector (y-axis) + */ + Vector3 GetUp() const; + + /** + * @return the down vector (inverse y-axis) + */ + Vector3 GetDown() const; + + /** + * @return the translation vector + */ + Vector3 GetTranslation() const; + + /** + * @return the values in the first column of the matrix + */ + Vector4 GetColumn1() const; + + /** + * @return the values in the second column of the matrix + */ + Vector4 GetColumn2() const; + + /** + * @return the values in the third column of the matrix + */ + Vector4 GetColumn3() const; + + /** + * @return the values in the fourth column of the matrix + */ + Vector4 GetColumn4() const; + + /** + * @return the values in the first row of the matrix + */ + Vector4 GetRow1() const; + + /** + * @return the values in the first row of the matrix + */ + Vector4 GetRow2() const; + + /** + * @return the values in the first row of the matrix + */ + Vector4 GetRow3() const; + + /** + * @return the values in the first row of the matrix + */ + Vector4 GetRow4() const; + + /** + * @return identity matrix + */ + static Matrix4x4 Identity(); + + /** + * Constructs a point billboard (spherical billboard) transformation matrix. + * @param objectPosition the position of the billboard object + * @param cameraPosition the position of the camera viewing the billboard + * @param cameraUp the up vector of the camera + * @param cameraForward the forward vector of the camera + * @return a billboard transformation matrix + */ + static Matrix4x4 CreateBillboard(const Vector3 &objectPosition, const Vector3 &cameraPosition, const Vector3 &cameraUp, const Vector3 &cameraForward); + + /** + * Creates a transformation matrix for a billboard that is constrained to + * rotate about an arbitrary axis. + * @param objectPosition the position of the billboard object + * @param cameraPosition the position of the camera viewing the billboard + * @param cameraForward the forward vector of the camera + * @param axis the axis that the billboard is to rotate about + * @return a billboard transformation matrix + */ + static Matrix4x4 CreateCylindricalBillboard(const Vector3 &objectPosition, const Vector3 &cameraPosition, const Vector3 &cameraForward, const Vector3 &axis); + + /** + * Constructs a "screen-aligned" billboard transformation matrix. + * @param objectPosition the position of the billboard object + * @param cameraUp the up vector of the camera + * @param cameraForward the forward vector of the camera + * @return a billboard transformation matrix + */ + static Matrix4x4 CreateScreenAlignedBillboard(const Vector3 &objectPosition, const Vector3 &cameraUp, const Vector3 &cameraForward); + + /** + * Constructs a "screen-aligned" billboard that is also then constrained + * to rotate about only a single axis (similar to a cylindrical + * billboard). + * @param objectPosition the position of the billboard object + * @param cameraForward the forward vector of the camera + * @param axis the axis that the billboard is to rotate about + * @return a billboard transformation matrix + */ + static Matrix4x4 CreateScreenAndAxisAlignedBillboard(const Vector3 &objectPosition, const Vector3 &cameraForward, const Vector3 &axis); + + /** + * Constructs a rotation matrix from Euler angles. + * @param x the x angle (in radians) + * @param y the y angle (in radians) + * @param z the z angle (in radians) + * @return a rotation matrix representing the provided angles + */ + static Matrix4x4 CreateFromEulerAngles(float x, float y, float z); + + /** + * Constructs a modelview matrix. This constructs the same matrix as a call + * to gluLookAt. + * @param cameraPosition position of the camera (eye) + * @param cameraTarget the direction the camera is pointing (center) + * @param cameraUp the up direction relative to the camera + * @return a modelview matrix + */ + static Matrix4x4 CreateLookAt(const Vector3 &cameraPosition, const Vector3 &cameraTarget, const Vector3 &cameraUp); + + /** + * Creates an orthogonal projection matrix. This is equivalent to a matrix + * created by using OpenGL's glOrtho() function. + * @param left coordinate of the left vertical clipping plane + * @param right coordinate of the right vertical clipping plane + * @param bottom coordinate of the bottom horizontal clipping plane + * @param top coordinate of the top horizontal clipping plane + * @param near near clipping plane distance (negative value is behind the viewer) + * @param far far clipping plane distance (negative value is behind the viewer) + * @return an orthogonal projection matrix + */ + static Matrix4x4 CreateOrthographic(float left, float right, float bottom, float top, float near_, float far_); + + /** + * Constructs a perspective projection matrix. This is equivalent to a + * matrix created by using OpenGL's glFrustum() function. + * @param left coordinate of the left vertical clipping plane + * @param right coordinate of the right vertical clipping plane + * @param bottom coordinate of the bottom horizontal clipping plane + * @param top coordinate of the top horizontal clipping plane + * @param near near clipping plane distance + * @param far far clipping plane distance + * @return a perspective projection matrix + */ + static Matrix4x4 CreatePerspective(float left, float right, float bottom, float top, float near_, float far_); + + /** + * Constructs a perspective projection matrix. This is equivalent to a + * matrix created by using OpenGL's gluPerspective() function. + * @param fieldOfView angle specifying the field of view (in radians) + * @param aspectRatio the aspect ratio of the viewport + * @param near near clipping plane distance + * @param far far clipping plane distance + * @return a perspective projection matrix + */ + static Matrix4x4 CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float near_, float far_); + + /** + * Sets up a rotation matrix about the specified axis. This returns a matrix + * equivalent to the matrix that OpenGL multiples into the modelview matrix + * whenever glRotate(angle, axis.x, axis.y, axis.z) is called. + * @param angle the angle to rotate by (in radians) + * @param axis unit vector denoting the axis for the rotation + * @return a rotation matrix representing the specific axis rotation + */ + static Matrix4x4 CreateRotation(float angle, const Vector3 &axis); + + /** + * Constructs a rotation matrix for a rotation around the x axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 1.0f, 0.0f, 0.0f) is called. + * @param angle angle to rotate the x axis around (in radians) + * @return the rotation matrix + */ + static Matrix4x4 CreateRotationX(float angle); + + /** + * Constructs a rotation matrix for a rotation around the y axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 0.0f, 1.0f, 0.0f) is called. + * @param angle angle to rotate the y axis around (in radians) + * @return the rotation matrix + */ + static Matrix4x4 CreateRotationY(float angle); + + /** + * Constructs a rotation matrix for a rotation around the z axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glRotate(angle, 0.0f, 0.0f, 1.0f) is called. + * @param angle angle to rotate the z axis around (in radians) + * @return the rotation matrix + */ + static Matrix4x4 CreateRotationZ(float angle); + + /** + * Constructs a scaling matrix from scaling factors for each axis. This returns + * a matrix equivalent to the matrix that OpenGL multiples into the modelview + * matrix whenever glScale(x, y, z) is called. + * @param x the scale factor for the x axis + * @param y the scale factor for the y axis + * @param z the scale factor for the z axis + * @return a scaling matrix + */ + static Matrix4x4 CreateScale(float x, float y, float z); + + /** + * Constructs a translation matrix. This returns a matrix equivalent to the + * matrix that OpenGL multiples into the modelview matrix whenever + * glTranslate(x, y, z) is called. + * @param x the amount to translate on the x axis + * @param y the amount to translate on the y axis + * @param z the amount to translate on the z axis + * @return a translation matrix + */ + static Matrix4x4 CreateTranslation(float x, float y, float z); + + /** + * Constructs a world matrix. + * @param position the position of the object (translation) + * @param forward the forward facing direction of the object + * @param up the up direction of the object + * @return a world matrix + */ + static Matrix4x4 CreateWorld(const Vector3 &position, const Vector3 &forward, const Vector3 &up); + + /** + * Calculates the inverse of the specified matrix. + * @param m the matrix to calculate the inverse of + * @return the inverse of the specified matrix + */ + static Matrix4x4 Inverse(const Matrix4x4 &m); + + /** + * Calculates the transpose of a given matrix. + * @param m the matrix to get the transpose of + * @return the transpose matrix + */ + static Matrix4x4 Transpose(const Matrix4x4 &m); + + /** + * Transforms the given vertex by a matrix. + * @param m the transformation matrix to use + * @param v the vertex to be transformed + * @return the transformed vertex + */ + static Vector3 Transform(const Matrix4x4 &m, const Vector3 &v); + + /** + * Transforms the given vertex by a matrix. + * @param m the transformation matrix to use + * @param v the vertex to be transformed + * @return the transformed vertex + */ + static Vector4 Transform(const Matrix4x4 &m, const Vector4 &v); + + /** + * Transforms the given vertex by a matrix using only the components of the + * matrix describing rotations (translation information not used). + * @param m the transformation matrix to use + * @param v the vertex to be transformed (rotated) + * @return the transformed (rotated) vertex + */ + static Vector3 TransformUsingRotationOnly(const Matrix4x4 &m, const Vector3 &v); + + float m[16]; +}; + +Matrix4x4 operator+(const Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 &operator+=(Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 operator-(const Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 &operator-=(Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 operator*(const Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 &operator*=(Matrix4x4 &left, const Matrix4x4 &right); +Matrix4x4 operator*(const Matrix4x4 &left, float right); +Matrix4x4 &operator*=(Matrix4x4 &left, float right); +Vector3 operator*(const Vector3 &left, const Matrix4x4 &right); +Vector4 operator*(const Vector4 &left, const Matrix4x4 &right); + +#define IDENTITY_MATRIX Matrix4x4::Identity() + +inline Matrix4x4::Matrix4x4() +{ +} + +inline Matrix4x4::Matrix4x4( + float m11, float m12, float m13, float m14, + float m21, float m22, float m23, float m24, + float m31, float m32, float m33, float m34, + float m41, float m42, float m43, float m44 + ) +{ + m[_11] = m11; + m[_12] = m12; + m[_13] = m13; + m[_14] = m14; + m[_21] = m21; + m[_22] = m22; + m[_23] = m23; + m[_24] = m24; + m[_31] = m31; + m[_32] = m32; + m[_33] = m33; + m[_34] = m34; + m[_41] = m41; + m[_42] = m42; + m[_43] = m43; + m[_44] = m44; +} + +inline Matrix4x4::Matrix4x4(const float *mv) +{ + m[_11] = mv[_11]; + m[_12] = mv[_12]; + m[_13] = mv[_13]; + m[_14] = mv[_14]; + m[_21] = mv[_21]; + m[_22] = mv[_22]; + m[_23] = mv[_23]; + m[_24] = mv[_24]; + m[_31] = mv[_31]; + m[_32] = mv[_32]; + m[_33] = mv[_33]; + m[_34] = mv[_34]; + m[_41] = mv[_41]; + m[_42] = mv[_42]; + m[_43] = mv[_43]; + m[_44] = mv[_44]; +} + +inline void Matrix4x4::Set( + float m11, float m12, float m13, float m14, + float m21, float m22, float m23, float m24, + float m31, float m32, float m33, float m34, + float m41, float m42, float m43, float m44 + ) +{ + m[_11] = m11; + m[_12] = m12; + m[_13] = m13; + m[_14] = m14; + m[_21] = m21; + m[_22] = m22; + m[_23] = m23; + m[_24] = m24; + m[_31] = m31; + m[_32] = m32; + m[_33] = m33; + m[_34] = m34; + m[_41] = m41; + m[_42] = m42; + m[_43] = m43; + m[_44] = m44; +} + +inline float Matrix4x4::GetDeterminant() const +{ + return + (m[_11] * m[_22] - m[_21] * m[_12]) * + (m[_33] * m[_44] - m[_43] * m[_34]) - + (m[_11] * m[_32] - m[_31] * m[_12]) * + (m[_23] * m[_44] - m[_43] * m[_24]) + + (m[_11] * m[_42] - m[_41] * m[_12]) * + (m[_23] * m[_34] - m[_33] * m[_24]) + + (m[_21] * m[_32] - m[_31] * m[_22]) * + (m[_13] * m[_44] - m[_43] * m[_14]) - + (m[_21] * m[_42] - m[_41] * m[_22]) * + (m[_13] * m[_34] - m[_33] * m[_14]) + + (m[_31] * m[_42] - m[_41] * m[_32]) * + (m[_13] * m[_24] - m[_23] * m[_14]); +} + +inline Vector3 Matrix4x4::GetForward() const +{ + return Vector3(m[_13], m[_23], m[_33]); +} + +inline Vector3 Matrix4x4::GetBackward() const +{ + return Vector3(-m[_13], -m[_23], -m[_33]); +} + +inline Vector3 Matrix4x4::GetLeft() const +{ + return Vector3(m[_11], m[_21], m[_31]); +} + +inline Vector3 Matrix4x4::GetRight() const +{ + return Vector3(-m[_11], -m[_21], -m[_31]); +} + +inline Vector3 Matrix4x4::GetUp() const +{ + return Vector3(m[_12], m[_22], m[_32]); +} + +inline Vector3 Matrix4x4::GetDown() const +{ + return Vector3(-m[_12], -m[_22], -m[_32]); +} + +inline Vector3 Matrix4x4::GetTranslation() const +{ + return Vector3(m[_14], m[_24], m[_34]); +} + +inline Vector4 Matrix4x4::GetColumn1() const +{ + return Vector4(m[_11], m[_21], m[_31], m[_41]); +} + +inline Vector4 Matrix4x4::GetColumn2() const +{ + return Vector4(m[_12], m[_22], m[_32], m[_42]); +} + +inline Vector4 Matrix4x4::GetColumn3() const +{ + return Vector4(m[_13], m[_23], m[_33], m[_43]); +} + +inline Vector4 Matrix4x4::GetColumn4() const +{ + return Vector4(m[_14], m[_24], m[_34], m[_44]); +} + +inline Vector4 Matrix4x4::GetRow1() const +{ + return Vector4(m[_11], m[_12], m[_13], m[_14]); +} + +inline Vector4 Matrix4x4::GetRow2() const +{ + return Vector4(m[_21], m[_22], m[_23], m[_24]); +} + +inline Vector4 Matrix4x4::GetRow3() const +{ + return Vector4(m[_31], m[_32], m[_33], m[_34]); +} + +inline Vector4 Matrix4x4::GetRow4() const +{ + return Vector4(m[_41], m[_42], m[_43], m[_44]); +} + +inline Matrix4x4 Matrix4x4::Identity() +{ + Matrix4x4 identity; + + identity.m[_11] = 1.0f; + identity.m[_12] = 0.0f; + identity.m[_13] = 0.0f; + identity.m[_14] = 0.0f; + identity.m[_21] = 0.0f; + identity.m[_22] = 1.0f; + identity.m[_23] = 0.0f; + identity.m[_24] = 0.0f; + identity.m[_31] = 0.0f; + identity.m[_32] = 0.0f; + identity.m[_33] = 1.0f; + identity.m[_34] = 0.0f; + identity.m[_41] = 0.0f; + identity.m[_42] = 0.0f; + identity.m[_43] = 0.0f; + identity.m[_44] = 1.0f; + + return identity; +} + +inline Matrix4x4 Matrix4x4::CreateBillboard(const Vector3 &objectPosition, const Vector3 &cameraPosition, const Vector3 &cameraUp, const Vector3 &cameraForward) +{ + Vector3 forward = objectPosition - cameraPosition; + float forwardLengthSquared = Vector3::LengthSquared(forward); + if (forwardLengthSquared < 0.0001f) + forward = -cameraForward; + else + forward = forward * (1.0f / (sqrtf(forwardLengthSquared))); + + Vector3 left = Vector3::Normalize(Vector3::Cross(cameraUp, forward)); + Vector3 up = Vector3::Cross(forward, left); + + Matrix4x4 out; + + out.m[_11] = left.x; + out.m[_21] = left.y; + out.m[_31] = left.z; + out.m[_41] = 0.0f; + + out.m[_12] = up.x; + out.m[_22] = up.y; + out.m[_32] = up.z; + out.m[_42] = 0.0f; + + out.m[_13] = forward.x; + out.m[_23] = forward.y; + out.m[_33] = forward.z; + out.m[_43] = 0.0f; + + out.m[_14] = objectPosition.x; + out.m[_24] = objectPosition.y; + out.m[_34] = objectPosition.z; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateCylindricalBillboard(const Vector3 &objectPosition, const Vector3 &cameraPosition, const Vector3 &cameraForward, const Vector3 &axis) +{ + Vector3 temp = objectPosition - cameraPosition; + float lengthSquared = Vector3::LengthSquared(temp); + if (lengthSquared < 0.0001f) + temp = -cameraForward; + else + temp = temp * (1.0f / (sqrtf(lengthSquared))); + + Vector3 up = axis; + Vector3 forward; + Vector3 left; + + float dot = Vector3::Dot(axis, temp); + if (fabsf(dot) > 0.9982547f) + { + dot = Vector3::Dot(axis, FORWARD); + if (fabsf(dot) > 0.9982547f) + forward = RIGHT; + else + forward = FORWARD; + + left = Vector3::Normalize(Vector3::Cross(axis, forward)); + forward = Vector3::Normalize(Vector3::Cross(left, axis)); + } + else + { + left = Vector3::Normalize(Vector3::Cross(axis, temp)); + forward = Vector3::Normalize(Vector3::Cross(left, up)); + } + + Matrix4x4 out; + + out.m[_11] = left.x; + out.m[_21] = left.y; + out.m[_31] = left.z; + out.m[_41] = 0.0f; + + out.m[_12] = up.x; + out.m[_22] = up.y; + out.m[_32] = up.z; + out.m[_42] = 0.0f; + + out.m[_13] = forward.x; + out.m[_23] = forward.y; + out.m[_33] = forward.z; + out.m[_43] = 0.0f; + + out.m[_14] = objectPosition.x; + out.m[_24] = objectPosition.y; + out.m[_34] = objectPosition.z; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateScreenAlignedBillboard(const Vector3 &objectPosition, const Vector3 &cameraUp, const Vector3 &cameraForward) +{ + Vector3 left = Vector3::Normalize(Vector3::Cross(cameraUp, cameraForward)); + Vector3 up = Vector3::Cross(cameraForward, left); + + Matrix4x4 out; + + out.m[_11] = left.x; + out.m[_21] = left.y; + out.m[_31] = left.z; + out.m[_41] = 0.0f; + + out.m[_12] = up.x; + out.m[_22] = up.y; + out.m[_32] = up.z; + out.m[_42] = 0.0f; + + out.m[_13] = cameraForward.x; + out.m[_23] = cameraForward.y; + out.m[_33] = cameraForward.z; + out.m[_43] = 0.0f; + + out.m[_14] = objectPosition.x; + out.m[_24] = objectPosition.y; + out.m[_34] = objectPosition.z; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateScreenAndAxisAlignedBillboard(const Vector3 &objectPosition, const Vector3 &cameraForward, const Vector3 &axis) +{ + Vector3 up = axis; + Vector3 forward; + Vector3 left; + + float dot = Vector3::Dot(axis, cameraForward); + if (fabsf(dot) > 0.9982547f) + { + dot = Vector3::Dot(axis, FORWARD); + if (fabsf(dot) > 0.9982547f) + forward = RIGHT; + else + forward = FORWARD; + + left = Vector3::Normalize(Vector3::Cross(axis, forward)); + forward = Vector3::Normalize(Vector3::Cross(left, axis)); + } + else + { + left = Vector3::Normalize(Vector3::Cross(axis, cameraForward)); + forward = Vector3::Normalize(Vector3::Cross(left, up)); + } + + Matrix4x4 out; + + out.m[_11] = left.x; + out.m[_21] = left.y; + out.m[_31] = left.z; + out.m[_41] = 0.0f; + + out.m[_12] = up.x; + out.m[_22] = up.y; + out.m[_32] = up.z; + out.m[_42] = 0.0f; + + out.m[_13] = forward.x; + out.m[_23] = forward.y; + out.m[_33] = forward.z; + out.m[_43] = 0.0f; + + out.m[_14] = objectPosition.x; + out.m[_24] = objectPosition.y; + out.m[_34] = objectPosition.z; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateFromEulerAngles(float x, float y, float z) +{ + Matrix4x4 rotateZ = CreateRotationZ(z); + Matrix4x4 rotateY = CreateRotationY(y); + Matrix4x4 rotateX = CreateRotationX(x); + + // "right-to-left" column-major matrix concatenation + return rotateZ * rotateY * rotateX; +} + +inline Matrix4x4 Matrix4x4::CreateLookAt(const Vector3 &cameraPosition, const Vector3 &cameraTarget, const Vector3 &cameraUp) +{ + Matrix4x4 out; + + // build basic lookat matrix without translation component included + Vector3 forward = Vector3::Normalize(cameraTarget - cameraPosition); + Vector3 left = Vector3::Normalize(Vector3::Cross(forward, cameraUp)); + Vector3 up = Vector3::Cross(left, forward); + + out.m[_11] = left.x; + out.m[_21] = up.x; + out.m[_31] = -forward.x; + out.m[_41] = 0.0f; + + out.m[_12] = left.y; + out.m[_22] = up.y; + out.m[_32] = -forward.y; + out.m[_42] = 0.0f; + + out.m[_13] = left.z; + out.m[_23] = up.z; + out.m[_33] = -forward.z; + out.m[_43] = 0.0f; + + out.m[_14] = 0.0f; + out.m[_24] = 0.0f; + out.m[_34] = 0.0f; + out.m[_44] = 1.0f; + + // multiply the translation into the lookat matrix + // this matrix multiplication is simplified so that we're only multiplying components that can actually affect the result + // out = Matrix4x4::CreateTranslation(-cameraPosition.x, -cameraPosition.y, -cameraPosition.z) * out; + out.m[_14] = out.m[_11] * -cameraPosition.x + out.m[_12] * -cameraPosition.y + out.m[_13] * -cameraPosition.z + out.m[_14]; + out.m[_24] = out.m[_21] * -cameraPosition.x + out.m[_22] * -cameraPosition.y + out.m[_23] * -cameraPosition.z + out.m[_24]; + out.m[_34] = out.m[_31] * -cameraPosition.x + out.m[_32] * -cameraPosition.y + out.m[_33] * -cameraPosition.z + out.m[_34]; + out.m[_44] = out.m[_41] * -cameraPosition.x + out.m[_42] * -cameraPosition.y + out.m[_43] * -cameraPosition.z + out.m[_44]; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateOrthographic(float left, float right, float bottom, float top, float near_, float far_) +{ + Matrix4x4 out; + + out.m[_11] = 2.0f / (right - left); + out.m[_12] = 0.0f; + out.m[_13] = 0.0f; + out.m[_14] = -((right + left) / (right - left)); + + out.m[_21] = 0.0f; + out.m[_22] = 2.0f / (top - bottom); + out.m[_23] = 0.0f; + out.m[_24] = -((top + bottom) / (top - bottom)); + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = -2.0f / (far_ - near_); + out.m[_34] = -((far_ + near_) / (far_ - near_)); + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreatePerspective(float left, float right, float bottom, float top, float near_, float far_) +{ + Matrix4x4 out; + + out.m[_11] = (2.0f * near_) / (right - left); + out.m[_12] = 0.0f; + out.m[_13] = (right + left) / (right - left); + out.m[_14] = 0.0f; + + out.m[_21] = 0.0f; + out.m[_22] = (2.0f * near_) / (top - bottom); + out.m[_23] = (top + bottom) / (top - bottom); + out.m[_24] = 0.0f; + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = -((far_ + near_)) / (far_ - near_); + out.m[_34] = -((2.0f * far_ * near_)) / (far_ - near_); + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = -1.0f; + out.m[_44] = 0.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float near_, float far_) +{ + Matrix4x4 out; + + float f = 1.0f / tanf(fieldOfView / 2.0f); + + out.m[_11] = f / aspectRatio; + out.m[_12] = 0.0f; + out.m[_13] = 0.0f; + out.m[_14] = 0.0f; + + out.m[_21] = 0.0f; + out.m[_22] = f; + out.m[_23] = 0.0f; + out.m[_24] = 0.0f; + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = (far_ + near_) / (near_ - far_); + out.m[_34] = (2.0f * far_ * near_) / (near_ - far_); + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = -1.0f; + out.m[_44] = 0.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateRotation(float angle, const Vector3 &axis) +{ + Matrix4x4 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[_11] = (axis.x * axis.x) * (1.0f - c) + c; + out.m[_12] = (axis.x * axis.y) * (1.0f - c) - (axis.z * s); + out.m[_13] = (axis.x * axis.z) * (1.0f - c) + (axis.y * s); + out.m[_14] = 0.0f; + + out.m[_21] = (axis.y * axis.x) * (1.0f - c) + (axis.z * s); + out.m[_22] = (axis.y * axis.y) * (1.0f - c) + c; + out.m[_23] = (axis.y * axis.z) * (1.0f - c) - (axis.x * s); + out.m[_24] = 0.0f; + + out.m[_31] = (axis.z * axis.x) * (1.0f - c) - (axis.y * s); + out.m[_32] = (axis.z * axis.y) * (1.0f - c) + (axis.x * s); + out.m[_33] = (axis.z * axis.z) * (1.0f - c) + c; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateRotationX(float angle) +{ + Matrix4x4 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[_11] = 1.0f; + out.m[_12] = 0.0f; + out.m[_13] = 0.0f; + out.m[_14] = 0.0f; + + out.m[_21] = 0.0f; + out.m[_22] = c; + out.m[_23] = -s; + out.m[_24] = 0.0f; + + out.m[_31] = 0.0f; + out.m[_32] = s; + out.m[_33] = c; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateRotationY(float angle) +{ + Matrix4x4 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[_11] = c; + out.m[_12] = 0.0f; + out.m[_13] = s; + out.m[_14] = 0.0f; + + out.m[_21] = 0.0f; + out.m[_22] = 1.0f; + out.m[_23] = 0.0f; + out.m[_24] = 0.0f; + + out.m[_31] = -s; + out.m[_32] = 0.0f; + out.m[_33] = c; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateRotationZ(float angle) +{ + Matrix4x4 out; + + float s = sinf(angle); + float c = cosf(angle); + + out.m[_11] = c; + out.m[_12] = -s; + out.m[_13] = 0.0f; + out.m[_14] = 0.0f; + + out.m[_21] = s; + out.m[_22] = c; + out.m[_23] = 0.0f; + out.m[_24] = 0.0f; + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = 1.0f; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateScale(float x, float y, float z) +{ + Matrix4x4 out; + + out.m[_11] = x; + out.m[_12] = 0.0f; + out.m[_13] = 0.0f; + out.m[_14] = 0.0f; + + out.m[_21] = 0.0f; + out.m[_22] = y; + out.m[_23] = 0.0f; + out.m[_24] = 0.0f; + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = z; + out.m[_34] = 0.0f; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateTranslation(float x, float y, float z) +{ + Matrix4x4 out; + + out.m[_11] = 1.0f; + out.m[_12] = 0.0f; + out.m[_13] = 0.0f; + out.m[_14] = x; + + out.m[_21] = 0.0f; + out.m[_22] = 1.0f; + out.m[_23] = 0.0f; + out.m[_24] = y; + + out.m[_31] = 0.0f; + out.m[_32] = 0.0f; + out.m[_33] = 1.0f; + out.m[_34] = z; + + out.m[_41] = 0.0f; + out.m[_42] = 0.0f; + out.m[_43] = 0.0f; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::CreateWorld(const Vector3 &position, const Vector3 &forward, const Vector3 &up) +{ + Matrix4x4 out; + + Vector3 f = Vector3::Normalize(-forward); + Vector3 l = Vector3::Normalize(Vector3::Cross(up, f)); + Vector3 u = Vector3::Cross(f, l); + + out.m[_11] = l.x; + out.m[_21] = l.y; + out.m[_31] = l.z; + out.m[_41] = 0.0f; + + out.m[_12] = u.x; + out.m[_22] = u.y; + out.m[_32] = u.z; + out.m[_42] = 0.0f; + + out.m[_13] = f.x; + out.m[_23] = f.y; + out.m[_33] = f.z; + out.m[_43] = 0.0f; + + out.m[_14] = position.x; + out.m[_24] = position.y; + out.m[_34] = position.z; + out.m[_44] = 1.0f; + + return out; +} + +inline Matrix4x4 Matrix4x4::Inverse(const Matrix4x4 &m) +{ + float d = m.GetDeterminant(); + if (IsCloseEnough(d, 0.0f)) + return IDENTITY_MATRIX; + else + { + Matrix4x4 out; + + d = 1.0f / d; + + out.m[_11] = d * (m.m[_22] * (m.m[_33] * m.m[_44] - m.m[_43] * m.m[_34]) + m.m[_32] * (m.m[_43] * m.m[_24] - m.m[_23] * m.m[_44]) + m.m[_42] * (m.m[_23] * m.m[_34] - m.m[_33] * m.m[_24])); + out.m[_21] = d * (m.m[_23] * (m.m[_31] * m.m[_44] - m.m[_41] * m.m[_34]) + m.m[_33] * (m.m[_41] * m.m[_24] - m.m[_21] * m.m[_44]) + m.m[_43] * (m.m[_21] * m.m[_34] - m.m[_31] * m.m[_24])); + out.m[_31] = d * (m.m[_24] * (m.m[_31] * m.m[_42] - m.m[_41] * m.m[_32]) + m.m[_34] * (m.m[_41] * m.m[_22] - m.m[_21] * m.m[_42]) + m.m[_44] * (m.m[_21] * m.m[_32] - m.m[_31] * m.m[_22])); + out.m[_41] = d * (m.m[_21] * (m.m[_42] * m.m[_33] - m.m[_32] * m.m[_43]) + m.m[_31] * (m.m[_22] * m.m[_43] - m.m[_42] * m.m[_23]) + m.m[_41] * (m.m[_32] * m.m[_23] - m.m[_22] * m.m[_33])); + + out.m[_12] = d * (m.m[_32] * (m.m[_13] * m.m[_44] - m.m[_43] * m.m[_14]) + m.m[_42] * (m.m[_33] * m.m[_14] - m.m[_13] * m.m[_34]) + m.m[_12] * (m.m[_43] * m.m[_34] - m.m[_33] * m.m[_44])); + out.m[_22] = d * (m.m[_33] * (m.m[_11] * m.m[_44] - m.m[_41] * m.m[_14]) + m.m[_43] * (m.m[_31] * m.m[_14] - m.m[_11] * m.m[_34]) + m.m[_13] * (m.m[_41] * m.m[_34] - m.m[_31] * m.m[_44])); + out.m[_32] = d * (m.m[_34] * (m.m[_11] * m.m[_42] - m.m[_41] * m.m[_12]) + m.m[_44] * (m.m[_31] * m.m[_12] - m.m[_11] * m.m[_32]) + m.m[_14] * (m.m[_41] * m.m[_32] - m.m[_31] * m.m[_42])); + out.m[_42] = d * (m.m[_31] * (m.m[_42] * m.m[_13] - m.m[_12] * m.m[_43]) + m.m[_41] * (m.m[_12] * m.m[_33] - m.m[_32] * m.m[_13]) + m.m[_11] * (m.m[_32] * m.m[_43] - m.m[_42] * m.m[_33])); + + out.m[_13] = d * (m.m[_42] * (m.m[_13] * m.m[_24] - m.m[_23] * m.m[_14]) + m.m[_12] * (m.m[_23] * m.m[_44] - m.m[_43] * m.m[_24]) + m.m[_22] * (m.m[_43] * m.m[_14] - m.m[_13] * m.m[_44])); + out.m[_23] = d * (m.m[_43] * (m.m[_11] * m.m[_24] - m.m[_21] * m.m[_14]) + m.m[_13] * (m.m[_21] * m.m[_44] - m.m[_41] * m.m[_24]) + m.m[_23] * (m.m[_41] * m.m[_14] - m.m[_11] * m.m[_44])); + out.m[_33] = d * (m.m[_44] * (m.m[_11] * m.m[_22] - m.m[_21] * m.m[_12]) + m.m[_14] * (m.m[_21] * m.m[_42] - m.m[_41] * m.m[_22]) + m.m[_24] * (m.m[_41] * m.m[_12] - m.m[_11] * m.m[_42])); + out.m[_43] = d * (m.m[_41] * (m.m[_22] * m.m[_13] - m.m[_12] * m.m[_23]) + m.m[_11] * (m.m[_42] * m.m[_23] - m.m[_22] * m.m[_43]) + m.m[_21] * (m.m[_12] * m.m[_43] - m.m[_42] * m.m[_13])); + + out.m[_14] = d * (m.m[_12] * (m.m[_33] * m.m[_24] - m.m[_23] * m.m[_34]) + m.m[_22] * (m.m[_13] * m.m[_34] - m.m[_33] * m.m[_14]) + m.m[_32] * (m.m[_23] * m.m[_14] - m.m[_13] * m.m[_24])); + out.m[_24] = d * (m.m[_13] * (m.m[_31] * m.m[_24] - m.m[_21] * m.m[_34]) + m.m[_23] * (m.m[_11] * m.m[_34] - m.m[_31] * m.m[_14]) + m.m[_33] * (m.m[_21] * m.m[_14] - m.m[_11] * m.m[_24])); + out.m[_34] = d * (m.m[_14] * (m.m[_31] * m.m[_22] - m.m[_21] * m.m[_32]) + m.m[_24] * (m.m[_11] * m.m[_32] - m.m[_31] * m.m[_12]) + m.m[_34] * (m.m[_21] * m.m[_12] - m.m[_11] * m.m[_22])); + out.m[_44] = d * (m.m[_11] * (m.m[_22] * m.m[_33] - m.m[_32] * m.m[_23]) + m.m[_21] * (m.m[_32] * m.m[_13] - m.m[_12] * m.m[_33]) + m.m[_31] * (m.m[_12] * m.m[_23] - m.m[_22] * m.m[_13])); + + return out; + } +} + +inline Matrix4x4 Matrix4x4::Transpose(const Matrix4x4 &m) +{ + Matrix4x4 out; + + out.m[_11] = m.m[_11]; + out.m[_12] = m.m[_21]; + out.m[_13] = m.m[_31]; + out.m[_14] = m.m[_41]; + + out.m[_21] = m.m[_12]; + out.m[_22] = m.m[_22]; + out.m[_23] = m.m[_32]; + out.m[_24] = m.m[_42]; + + out.m[_31] = m.m[_13]; + out.m[_32] = m.m[_23]; + out.m[_33] = m.m[_33]; + out.m[_34] = m.m[_43]; + + out.m[_41] = m.m[_14]; + out.m[_42] = m.m[_24]; + out.m[_43] = m.m[_34]; + out.m[_44] = m.m[_44]; + + return out; +} + +inline Vector3 Matrix4x4::Transform(const Matrix4x4 &m, const Vector3 &v) +{ + Vector3 out; + + out.x = v.x * m.m[_11] + v.y * m.m[_12] + v.z * m.m[_13] + m.m[_14]; + out.y = v.x * m.m[_21] + v.y * m.m[_22] + v.z * m.m[_23] + m.m[_24]; + out.z = v.x * m.m[_31] + v.y * m.m[_32] + v.z * m.m[_33] + m.m[_34]; + + return out; +} + +inline Vector4 Matrix4x4::Transform(const Matrix4x4 &m, const Vector4 &v) +{ + Vector4 out; + + out.x = v.x * m.m[_11] + v.y * m.m[_12] + v.z * m.m[_13] + v.w * m.m[_14]; + out.y = v.x * m.m[_21] + v.y * m.m[_22] + v.z * m.m[_23] + v.w * m.m[_24]; + out.z = v.x * m.m[_31] + v.y * m.m[_32] + v.z * m.m[_33] + v.w * m.m[_34]; + out.w = v.x * m.m[_41] + v.y * m.m[_42] + v.z * m.m[_43] + v.w * m.m[_44]; + + return out; +} + +inline Vector3 Matrix4x4::TransformUsingRotationOnly(const Matrix4x4 &m, const Vector3 &v) +{ + Vector3 out; + + out.x = v.x * m.m[_11] + v.y * m.m[_12] + v.z * m.m[_13]; + out.y = v.x * m.m[_21] + v.y * m.m[_22] + v.z * m.m[_23]; + out.z = v.x * m.m[_31] + v.y * m.m[_32] + v.z * m.m[_33]; + + return out; +} + +inline Matrix4x4 operator+(const Matrix4x4 &left, const Matrix4x4 &right) +{ + Matrix4x4 result; + + result.m[_11] = left.m[_11] + right.m[_11]; + result.m[_12] = left.m[_12] + right.m[_12]; + result.m[_13] = left.m[_13] + right.m[_13]; + result.m[_14] = left.m[_14] + right.m[_14]; + result.m[_21] = left.m[_21] + right.m[_21]; + result.m[_22] = left.m[_22] + right.m[_22]; + result.m[_23] = left.m[_23] + right.m[_23]; + result.m[_24] = left.m[_24] + right.m[_24]; + result.m[_31] = left.m[_31] + right.m[_31]; + result.m[_32] = left.m[_32] + right.m[_32]; + result.m[_33] = left.m[_33] + right.m[_33]; + result.m[_34] = left.m[_34] + right.m[_34]; + result.m[_41] = left.m[_41] + right.m[_41]; + result.m[_42] = left.m[_42] + right.m[_42]; + result.m[_43] = left.m[_43] + right.m[_43]; + result.m[_44] = left.m[_44] + right.m[_44]; + + return result; +} + +inline Matrix4x4 &operator+=(Matrix4x4 &left, const Matrix4x4 &right) +{ + left = left + right; + return left; +} + +inline Matrix4x4 operator-(const Matrix4x4 &left, const Matrix4x4 &right) +{ + Matrix4x4 result; + + result.m[_11] = left.m[_11] - right.m[_11]; + result.m[_12] = left.m[_12] - right.m[_12]; + result.m[_13] = left.m[_13] - right.m[_13]; + result.m[_14] = left.m[_14] - right.m[_14]; + result.m[_21] = left.m[_21] - right.m[_21]; + result.m[_22] = left.m[_22] - right.m[_22]; + result.m[_23] = left.m[_23] - right.m[_23]; + result.m[_24] = left.m[_24] - right.m[_24]; + result.m[_31] = left.m[_31] - right.m[_31]; + result.m[_32] = left.m[_32] - right.m[_32]; + result.m[_33] = left.m[_33] - right.m[_33]; + result.m[_34] = left.m[_34] - right.m[_34]; + result.m[_41] = left.m[_41] - right.m[_41]; + result.m[_42] = left.m[_42] - right.m[_42]; + result.m[_43] = left.m[_43] - right.m[_43]; + result.m[_44] = left.m[_44] - right.m[_44]; + + return result; +} + +inline Matrix4x4 &operator-=(Matrix4x4 &left, const Matrix4x4 &right) +{ + left = left - right; + return left; +} + +inline Matrix4x4 operator*(const Matrix4x4 &left, const Matrix4x4 &right) +{ + Matrix4x4 result; + + result.m[_11] = left.m[_11] * right.m[_11] + left.m[_12] * right.m[_21] + left.m[_13] * right.m[_31] + left.m[_14] * right.m[_41]; + result.m[_12] = left.m[_11] * right.m[_12] + left.m[_12] * right.m[_22] + left.m[_13] * right.m[_32] + left.m[_14] * right.m[_42]; + result.m[_13] = left.m[_11] * right.m[_13] + left.m[_12] * right.m[_23] + left.m[_13] * right.m[_33] + left.m[_14] * right.m[_43]; + result.m[_14] = left.m[_11] * right.m[_14] + left.m[_12] * right.m[_24] + left.m[_13] * right.m[_34] + left.m[_14] * right.m[_44]; + + result.m[_21] = left.m[_21] * right.m[_11] + left.m[_22] * right.m[_21] + left.m[_23] * right.m[_31] + left.m[_24] * right.m[_41]; + result.m[_22] = left.m[_21] * right.m[_12] + left.m[_22] * right.m[_22] + left.m[_23] * right.m[_32] + left.m[_24] * right.m[_42]; + result.m[_23] = left.m[_21] * right.m[_13] + left.m[_22] * right.m[_23] + left.m[_23] * right.m[_33] + left.m[_24] * right.m[_43]; + result.m[_24] = left.m[_21] * right.m[_14] + left.m[_22] * right.m[_24] + left.m[_23] * right.m[_34] + left.m[_24] * right.m[_44]; + + result.m[_31] = left.m[_31] * right.m[_11] + left.m[_32] * right.m[_21] + left.m[_33] * right.m[_31] + left.m[_34] * right.m[_41]; + result.m[_32] = left.m[_31] * right.m[_12] + left.m[_32] * right.m[_22] + left.m[_33] * right.m[_32] + left.m[_34] * right.m[_42]; + result.m[_33] = left.m[_31] * right.m[_13] + left.m[_32] * right.m[_23] + left.m[_33] * right.m[_33] + left.m[_34] * right.m[_43]; + result.m[_34] = left.m[_31] * right.m[_14] + left.m[_32] * right.m[_24] + left.m[_33] * right.m[_34] + left.m[_34] * right.m[_44]; + + result.m[_41] = left.m[_41] * right.m[_11] + left.m[_42] * right.m[_21] + left.m[_43] * right.m[_31] + left.m[_44] * right.m[_41]; + result.m[_42] = left.m[_41] * right.m[_12] + left.m[_42] * right.m[_22] + left.m[_43] * right.m[_32] + left.m[_44] * right.m[_42]; + result.m[_43] = left.m[_41] * right.m[_13] + left.m[_42] * right.m[_23] + left.m[_43] * right.m[_33] + left.m[_44] * right.m[_43]; + result.m[_44] = left.m[_41] * right.m[_14] + left.m[_42] * right.m[_24] + left.m[_43] * right.m[_34] + left.m[_44] * right.m[_44]; + + return result; +} + +inline Matrix4x4 &operator*=(Matrix4x4 &left, const Matrix4x4 &right) +{ + left = left * right; + return left; +} + +inline Matrix4x4 operator*(const Matrix4x4 &left, float right) +{ + Matrix4x4 result; + + result.m[_11] = left.m[_11] * right; + result.m[_12] = left.m[_12] * right; + result.m[_13] = left.m[_13] * right; + result.m[_14] = left.m[_14] * right; + result.m[_21] = left.m[_21] * right; + result.m[_22] = left.m[_22] * right; + result.m[_23] = left.m[_23] * right; + result.m[_24] = left.m[_24] * right; + result.m[_31] = left.m[_31] * right; + result.m[_32] = left.m[_32] * right; + result.m[_33] = left.m[_33] * right; + result.m[_34] = left.m[_34] * right; + result.m[_41] = left.m[_41] * right; + result.m[_42] = left.m[_42] * right; + result.m[_43] = left.m[_43] * right; + result.m[_44] = left.m[_44] * right; + + return result; +} + +inline Matrix4x4 &operator*=(Matrix4x4 &left, float right) +{ + left = left * right; + return left; +} + +inline Vector3 operator*(const Vector3 &left, const Matrix4x4 &right) +{ + return Matrix4x4::Transform(right, left); +} + +inline Vector4 operator*(const Vector4 &left, const Matrix4x4 &right) +{ + return Matrix4x4::Transform(right, left); +} + +#endif + diff --git a/src/framework/math/matrixstack.h b/src/framework/math/matrixstack.h new file mode 100644 index 0000000..84a00f3 --- /dev/null +++ b/src/framework/math/matrixstack.h @@ -0,0 +1,62 @@ +#ifndef __FRAMEWORK_MATH_MATRIXSTACK_H_INCLUDED__ +#define __FRAMEWORK_MATH_MATRIXSTACK_H_INCLUDED__ + +#include "matrix4x4.h" +#include + +/** + * Manages a LIFO stack of matrices. + */ +class MatrixStack +{ +public: + /** + * Creates an empty matrix stack. + */ + MatrixStack(); + + /** + * Pushes the stack down by one, duplicating the current matrix. + */ + void Push(); + + /** + * Pops the stack, replacing the top matrix with the one under it. + */ + void Pop(); + + /** + * Removes all items on the stack and resets the top matrix. + */ + void Clear(); + + Matrix4x4 top; + +private: + stl::list m_stack; +}; + +inline MatrixStack::MatrixStack() +{ + top = Matrix4x4(); + m_stack.resize(16, Matrix4x4()); +} + +inline void MatrixStack::Push() +{ + m_stack.push_back(top); +} + +inline void MatrixStack::Pop() +{ + top = m_stack.back(); + m_stack.pop_back(); +} + +inline void MatrixStack::Clear() +{ + top = Matrix4x4(); + m_stack.clear(); +} + +#endif diff --git a/src/framework/math/plane.h b/src/framework/math/plane.h new file mode 100644 index 0000000..6375018 --- /dev/null +++ b/src/framework/math/plane.h @@ -0,0 +1,177 @@ +#ifndef __FRAMEWORK_MATH_PLANE_H_INCLUDED__ +#define __FRAMEWORK_MATH_PLANE_H_INCLUDED__ + +#include "../common.h" +#include +#include "vector3.h" + +enum PLANE_POINT_CLASSIFY +{ + IN_FRONT = 0, + BEHIND = 1, + ON_PLANE = 2 +}; + +/** + *

Represents a plane of the form:

+ * Ax + Bx + Cx + D = 0 + *

Provides common methods for working with planes.

+ *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • http://www.peroxide.dk/papers/collision/collision.pdf
    • + *
+ */ +struct Plane +{ +/** + * Creates an uninitialized plane. + */ + Plane(); + + /** + * Creates a plane with the specified properties. + */ + Plane(float a, float b, float c, float d); + + /** + * Creates a plane with the specified properties. + * @param p an array of 4 values that will be used for this plane's components + */ + Plane(const float *p); + + /** + * Creates a plane with the specified properties. + * @param origin a point that lies on the plane being created + * @param normal the normal of the plane + */ + Plane(const Vector3 &origin, const Vector3 &normal); + + /** + * Creates a plane with the specified properties. + * @param a first point of a triangle that lies on the plane + * @param b second point of a triangle that lies on the plane + * @param c third point of a triangle that lies on the plane + */ + Plane(const Vector3 &a, const Vector3 &b, const Vector3 &c); + + /** + * Determines if a point is in front, behind or located on a plane. + * @param plane plane to check + * @param point point to classify + * @return result of the classification test + */ + static PLANE_POINT_CLASSIFY ClassifyPoint(const Plane &plane, const Vector3 &point); + + /** + * Calculates the distance between a plane and a point. If the distance is + * negative the point is located behind the plane. + * @param plane plane to check + * @param point point to measure to + * @return the distance between the plane and the point + */ + static float DistanceBetween(const Plane &plane, const Vector3 &point); + + /** + * Determines if a direction is point roughly towards the front side of a + * plane (i.e. theta is in the range 90 - 180). + * @param plane plane to check + * @param direction direction to classify + * @return true if the direction is pointing towards the front side of the + * plane + */ + static BOOL IsFrontFacingTo(const Plane &plane, const Vector3 &direction); + + /** + * Normalize a plane. + * @param plane plane to normalize + * @return the normalized plane + */ + static Plane Normalize(const Plane &plane); + + Vector3 normal; + float d; +}; + +inline Plane::Plane() +{ +} + +inline Plane::Plane(float a, float b, float c, float d) +{ + normal.x = a; + normal.y = b; + normal.z = c; + this->d = d; +} + +inline Plane::Plane(const float *p) +{ + normal.x = p[0]; + normal.y = p[1]; + normal.z = p[2]; + d = p[3]; +} + +inline Plane::Plane(const Vector3 &origin, const Vector3 &normal) +{ + this->normal.x = normal.x; + this->normal.y = normal.y; + this->normal.z = normal.z; + d = -Vector3::Dot(origin, normal); +} + +inline Plane::Plane(const Vector3 &a, const Vector3 &b, const Vector3 &c) +{ + Vector3 e3 = b - a; + Vector3 e1 = c - b; + Vector3 crossed = Vector3::Cross(e3, e1); + float scaleFactor = 1.0f / Vector3::Length(crossed); + + normal = crossed * scaleFactor; + + d = -Vector3::Dot(a, normal); +} + +inline PLANE_POINT_CLASSIFY Plane::ClassifyPoint(const Plane &plane, const Vector3 &point) +{ + float planeDot = Vector3::Dot(plane.normal, point) + plane.d; + + if (planeDot < 0.0f) + return BEHIND; + else if (planeDot > 0.0f) + return IN_FRONT; + else + return ON_PLANE; +} + +inline float Plane::DistanceBetween(const Plane &plane, const Vector3 &point) +{ + return Vector3::Dot(point, plane.normal) + plane.d; +} + +inline BOOL Plane::IsFrontFacingTo(const Plane &plane, const Vector3 &direction) +{ + if (Vector3::Dot(plane.normal, direction) <= 0.0f) + return true; + else + return false; +} + +inline Plane Plane::Normalize(const Plane &plane) +{ + float length = sqrtf( + (plane.normal.x * plane.normal.x) + + (plane.normal.y * plane.normal.y) + + (plane.normal.z * plane.normal.z) + ); + return Plane( + plane.normal.x / length, + plane.normal.y / length, + plane.normal.z / length, + plane.d / length + ); +} + +#endif + diff --git a/src/framework/math/point2.h b/src/framework/math/point2.h new file mode 100644 index 0000000..9375540 --- /dev/null +++ b/src/framework/math/point2.h @@ -0,0 +1,179 @@ +#ifndef __FRAMEWORK_MATH_POINT2_H_INCLUDED__ +#define __FRAMEWORK_MATH_POINT2_H_INCLUDED__ +#include "../common.h" + +/** + * Represents a point in 2D space using integers for the coordinates. + */ +struct Point2 +{ + /** + * Creates an uninitialized point. + */ + Point2(); + + /** + * Creates a point with the specified properties. + * @param x X coordinate of the point + * @param y Y coordinate of the point + */ + Point2(int32_t x, int32_t y); + + /** + * Creates a point with the specified properties. + * @param p an array with 2 values to use as the point's X and Y coordinates + */ + Point2(const int32_t *p); + + /** + * Sets new coordinates for this point. + * @param x new X coordinate of the point + * @param y new Y coordinate of the point + */ + void Set(int32_t x, int32_t y); + + /** + * Sets new coordinates for this point. + * @param p another point whose coordinates are to be copied and used for this point + */ + void Set(const Point2 &p); + + int32_t x; + int32_t y; +}; + +#define ZERO_POINT2 Point2(0, 0) + +bool operator==(const Point2 &left, const Point2 &right); +Point2 operator-(const Point2 &left); +Point2 operator+(const Point2 &left, const Point2 &right); +Point2 &operator+=(Point2 &left, const Point2 &right); +Point2 operator-(const Point2 &left, const Point2 &right); +Point2 &operator-=(Point2 &left, const Point2 &right); +Point2 operator*(const Point2 &left, int32_t right); +Point2 &operator*=(Point2 &left, int32_t right); +Point2 operator/(const Point2 &left, int32_t right); +Point2 &operator/=(Point2 &left, int32_t right); +Point2 operator*(const Point2 &left, const Point2 &right); +Point2 &operator*=(Point2 &left, const Point2 &right); +Point2 operator/(const Point2 &left, const Point2 &right); +Point2 &operator/=(Point2 &left, const Point2 &right); + +inline Point2::Point2() +{ +} + +inline Point2::Point2(int32_t x, int32_t y) +{ + this->x = x; + this->y = y; +} + +inline Point2::Point2(const int32_t *p) +{ + this->x = p[0]; + this->y = p[1]; +} + +inline void Point2::Set(int32_t x, int32_t y) +{ + this->x = x; + this->y = y; +} + +inline void Point2::Set(const Point2 &p) +{ + this->x = p.x; + this->y = p.y; +} + +inline bool operator==(const Point2 &left, const Point2 &right) +{ + return (left.x == right.x && left.y == right.y); +} + +inline Point2 operator-(const Point2 &left) +{ + return Point2(-left.x, -left.y); +} + +inline Point2 operator+(const Point2 &left, const Point2 &right) +{ + return Point2(left.x + right.x, left.y + right.y); +} + +inline Point2 &operator+=(Point2 &left, const Point2 &right) +{ + left.x += right.x; + left.y += right.y; + + return left; +} + +inline Point2 operator-(const Point2 &left, const Point2 &right) +{ + return Point2(left.x - right.x, left.y - right.y); +} + +inline Point2 &operator-=(Point2 &left, const Point2 &right) +{ + left.x -= right.x; + left.y -= right.y; + + return left; +} + +inline Point2 operator*(const Point2 &left, int32_t right) +{ + return Point2(left.x * right, left.y * right); +} + +inline Point2 &operator*=(Point2 &left, int32_t right) +{ + left.x *= right; + left.y *= right; + + return left; +} + +inline Point2 operator/(const Point2 &left, int32_t right) +{ + return Point2(left.x / right, left.y / right); +} + +inline Point2 &operator/=(Point2 &left, int32_t right) +{ + left.x /= right; + left.y /= right; + + return left; +} + +inline Point2 operator*(const Point2 &left, const Point2 &right) +{ + return Point2(left.x * right.x, left.y * right.y); +} + +inline Point2 &operator*=(Point2 &left, const Point2 &right) +{ + left.x *= right.x; + left.y *= right.y; + + return left; +} + +inline Point2 operator/(const Point2 &left, const Point2 &right) +{ + return Point2(left.x / right.x, left.y / right.y); +} + +inline Point2 &operator/=(Point2 &left, const Point2 &right) +{ + left.x /= right.x; + left.y /= right.y; + + return left; +} + +#endif + diff --git a/src/framework/math/point3.h b/src/framework/math/point3.h new file mode 100644 index 0000000..279e316 --- /dev/null +++ b/src/framework/math/point3.h @@ -0,0 +1,193 @@ +#ifndef __FRAMEWORK_MATH_POINT3_H_INCLUDED__ +#define __FRAMEWORK_MATH_POINT3_H_INCLUDED__ + +#include "../common.h" + +/** + * Represents a point in 3D space using integers for the coordinates. + */ +struct Point3 +{ + /** + * Creates an uninitialized point. + */ + Point3(); + + /** + * Creates a point with the specified properties. + * @param x X coordinate of the point + * @param y Y coordinate of the point + * @param z Z coordinate of the point + */ + Point3(int32_t x, int32_t y, int32_t z); + + /** + * Creates a point with the specified properties. + * @param p an array with 3 values to use as the point's X, Y and Z coordinates + */ + Point3(const int32_t *p); + + /** + * Sets new coordinates for this point. + * @param x new X coordinate of the point + * @param y new Y coordinate of the point + * @param z new Z coordinate of the point + */ + void Set(int32_t x, int32_t y, int32_t z); + + /** + * Sets new coordinates for this point. + * @param p another point whose coordinates are to be copied and used for this point + */ + void Set(const Point3 &p); + + int32_t x; + int32_t y; + int32_t z; +}; + +#define ZERO_POINT Point3(0, 0, 0) + +bool operator==(const Point3 &left, const Point3 &right); +Point3 operator-(const Point3 &left); +Point3 operator+(const Point3 &left, const Point3 &right); +Point3 &operator+=(Point3 &left, const Point3 &right); +Point3 operator-(const Point3 &left, const Point3 &right); +Point3 &operator-=(Point3 &left, const Point3 &right); +Point3 operator*(const Point3 &left, int32_t right); +Point3 &operator*=(Point3 &left, int32_t right); +Point3 operator/(const Point3 &left, int32_t right); +Point3 &operator/=(Point3 &left, int32_t right); +Point3 operator*(const Point3 &left, const Point3 &right); +Point3 &operator*=(Point3 &left, const Point3 &right); +Point3 operator/(const Point3 &left, const Point3 &right); +Point3 &operator/=(Point3 &left, const Point3 &right); + +inline Point3::Point3() +{ +} + +inline Point3::Point3(int32_t x, int32_t y, int32_t z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +inline Point3::Point3(const int32_t *p) +{ + this->x = p[0]; + this->y = p[1]; + this->z = p[2]; +} + +inline void Point3::Set(int32_t x, int32_t y, int32_t z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +inline void Point3::Set(const Point3 &p) +{ + this->x = p.x; + this->y = p.y; + this->z = p.z; +} + +inline bool operator==(const Point3 &left, const Point3 &right) +{ + return (left.x == right.x && left.y == right.y && left.z == right.z); +} + +inline Point3 operator-(const Point3 &left) +{ + return Point3(-left.x, -left.y, -left.z); +} + +inline Point3 operator+(const Point3 &left, const Point3 &right) +{ + return Point3(left.x + right.x, left.y + right.y, left.z + right.z); +} + +inline Point3 &operator+=(Point3 &left, const Point3 &right) +{ + left.x += right.x; + left.y += right.y; + left.z += right.z; + + return left; +} + +inline Point3 operator-(const Point3 &left, const Point3 &right) +{ + return Point3(left.x - right.x, left.y - right.y, left.z - right.z); +} + +inline Point3 &operator-=(Point3 &left, const Point3 &right) +{ + left.x -= right.x; + left.y -= right.y; + left.z -= right.z; + + return left; +} + +inline Point3 operator*(const Point3 &left, int32_t right) +{ + return Point3(left.x * right, left.y * right, left.z * right); +} + +inline Point3 &operator*=(Point3 &left, int32_t right) +{ + left.x *= right; + left.y *= right; + left.z *= right; + + return left; +} + +inline Point3 operator/(const Point3 &left, int32_t right) +{ + return Point3(left.x / right, left.y / right, left.z / right); +} + +inline Point3 &operator/=(Point3 &left, int32_t right) +{ + left.x /= right; + left.y /= right; + left.z /= right; + + return left; +} + +inline Point3 operator*(const Point3 &left, const Point3 &right) +{ + return Point3(left.x * right.x, left.y * right.y, left.z * right.z); +} + +inline Point3 &operator*=(Point3 &left, const Point3 &right) +{ + left.x *= right.x; + left.y *= right.y; + left.z *= right.z; + + return left; +} + +inline Point3 operator/(const Point3 &left, const Point3 &right) +{ + return Point3(left.x / right.x, left.y / right.y, left.z / right.z); +} + +inline Point3 &operator/=(Point3 &left, const Point3 &right) +{ + left.x /= right.x; + left.y /= right.y; + left.z /= right.z; + + return left; +} + +#endif + diff --git a/src/framework/math/quaternion.h b/src/framework/math/quaternion.h new file mode 100644 index 0000000..8306117 --- /dev/null +++ b/src/framework/math/quaternion.h @@ -0,0 +1,525 @@ +#ifndef __FRAMEWORK_MATH_QUATERNION_H_INCLUDED__ +#define __FRAMEWORK_MATH_QUATERNION_H_INCLUDED__ + +#include +#include "common.h" +#include "vector3.h" +#include "matrix4x4.h" + +/** + * Represents a quaternion to store an orientation or angular + * displacement and provides methods for conversion/manipulation + *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • More OpenGL Game Programming (Dave Astle, 2006)
    • + *
  • http://www.dhpoware.com/source/mathlib.html
    • + *
+ */ +struct Quaternion +{ + /** + * Creates an uninitialized quaternion. + */ + Quaternion(); + + /** + * Creates a quaternion with the specified properties. + */ + Quaternion(float x, float y, float z, float w); + + /** + * Creates a quaternion with the specified properties. + */ + Quaternion(const Vector3 &v, float w); + + /** + * Creates a quaternion with the specified properties. + * @param q an array with 4 values that will be used as this quaternion's components + */ + Quaternion(const float *q); + + /** + * Set new component values for this quaternion. + */ + void Set(float x, float y, float z, float w); + + /** + * Converts a quaternion to a rotation matrix. + * @return equivalent rotation matrix + */ + Matrix4x4 ToMatrix() const; + + /** + * @return the vector component of the quaternion. + */ + Vector3 GetVector() const; + + /** + * Computes the conjugate of a quaternion. If the quaternion + * is unit length, this also returns the inverse. + * @param q quaternion to retrieve the conjugate of + * @return the conjugate of the quaternion + */ + static Quaternion Conjugate(const Quaternion &q); + + /** + * Converts Euler angles to a quaternion. + * @param x x angle of rotation (in radians) + * @param y y angle of rotation (in radians) + * @param z z angle of rotation (in radians) + * @return quaternion equivalent to the Euler angle orientation + */ + static Quaternion CreateFromEulerAngles(float x, float y, float z); + + /** + * Converts an axis angle to a quaternion. + * @param angle the angle to rotate be (in radians) + * @param axis the axis being rotated about + * @return quaternion equivalent to the axis angle orientation + */ + static Quaternion CreateFromAxisAngle(float angle, const Vector3 &axis); + + /** + * Converts a rotation matrix to a quaternion. + * @param matrix matrix to be converted + * @return quaternion equivalent of the rotation matrix + */ + static Quaternion CreateFromRotationMatrix(const Matrix4x4 &matrix); + + /** + * Computes the cross product of two quaternions. + * @param a first quaternion + * @param b second quaternion + * @return the cross product + */ + static Quaternion Cross(const Quaternion &a, const Quaternion &b); + + /** + * Computes the dot product of 2 quaternions. + * @param a first quaternion + * @param b second quaternion + * @return the dot product + */ + static float Dot(const Quaternion &a, const Quaternion &b); + + /** + * Converts a quaternion to an axis-angle representation. + * @param q the normalized quaternion to convert + * @param angle the angle (in radians) + * @param axis a vector that will contain the axis + */ + static void ExtractAxisAngle(const Quaternion &q, float &angle, Vector3 &axis); + + /** + * Computes the inverse of a given quaternion. + * @param q quaternion to retrieve the inverse of + * @return inverse of the quaternion + */ + static Quaternion Inverse(const Quaternion &q); + + /** + * Computes the length (magnitude) of a quaternion. + * @param q quaternion to retrieve the length of + * @return the length + */ + static float Length(const Quaternion &q); + + /** + * Computes the squared length of a quaternion (the length minus the + * sqrt call). + * @param q quaternion to retrieve the squared length of + * @return the squared length + */ + static float LengthSquared(const Quaternion &q); + + /** + * Linearly interpolates between two quaternions. + * @param a the first quaternion + * @param b the second quaternion + * @param interpolation the amount to interpolate + * @return the interpolated quaternion + */ + static Quaternion Lerp(const Quaternion &a, const Quaternion &b, float interpolation); + + /** + * Normalizes a quaternion (only if necessary). + * @param q quaternion to be normalized + * @return the normalized quaternion + */ + static Quaternion Normalize(const Quaternion &q); + + /** + * Interpolates between two quaternions using spherical + * interpolation. + * @param a the first quaternion + * @param b the second quaternion + * @param interpolation the amount to interpolate + * @return the interpolated quaternion + */ + static Quaternion Slerp(const Quaternion &a, const Quaternion &b, float interpolation); + + float x; + float y; + float z; + float w; +}; + +Quaternion operator+(const Quaternion &left, const Quaternion &right); +Quaternion &operator+=(Quaternion &left, const Quaternion &right); +Quaternion operator-(const Quaternion &left, const Quaternion &right); +Quaternion &operator-=(Quaternion &left, const Quaternion &right); +Quaternion operator*(const Quaternion &left, float right); +Quaternion &operator*=(Quaternion &left, float right); +Quaternion operator*(const Quaternion &left, const Quaternion &right); +Quaternion &operator*=(Quaternion &left, const Quaternion &right); +Quaternion operator/(const Quaternion &left, float right); +Quaternion &operator/=(Quaternion &left, float right); +Vector3 operator*(const Vector3 &left, const Quaternion &right); + +#define IDENTITY_QUATERNION Quaternion(0.0f, 0.0f, 0.0f, 1.0f) + +inline Quaternion::Quaternion() +{ +} + +inline Quaternion::Quaternion(float x, float y, float z, float w) +{ + this->x = x; + this->y = y; + this->z = z; + this->w = w; +} + +inline Quaternion::Quaternion(const Vector3 &v, float w) +{ + this->x = v.x; + this->y = v.y; + this->z = v.z; + this->w = w; +} + +inline Quaternion::Quaternion(const float *q) +{ + x = q[0]; + y = q[1]; + z = q[2]; + w = q[3]; +} + +inline void Quaternion::Set(float x, float y, float z, float w) +{ + this->x = x; + this->y = y; + this->z = z; + this->w = w; +} + +inline Matrix4x4 Quaternion::ToMatrix() const +{ + Matrix4x4 output; + + output.m[_11] = 1.0f - (2.0f * ((y * y) + (z * z))); + output.m[_21] = 2.0f * ((x * y) + (z * w)); + output.m[_31] = 2.0f * ((z * x) - (y * w)); + output.m[_41] = 0.0f; + + output.m[_12] = 2.0f * ((x * y) - (z * w)); + output.m[_22] = 1.0f - (2.0f * ((z * z) + (x * x))); + output.m[_32] = 2.0f * ((y * z) + (x * w)); + output.m[_42] = 0.0f; + + output.m[_13] = 2.0f * ((z * x) + (y * w)); + output.m[_23] = 2.0f * ((y * z) - (x * w)); + output.m[_33] = 1.0f - (2.0f * ((y * y) + (x * x))); + output.m[_43] = 0.0f; + + output.m[_14] = 0.0f; + output.m[_24] = 0.0f; + output.m[_34] = 0.0f; + output.m[_44] = 1.0f; + + return output; +} + +inline Vector3 Quaternion::GetVector() const +{ + return Vector3(x, y, z); +} + +inline Quaternion Quaternion::Conjugate(const Quaternion &q) +{ + return Quaternion(-q.x, -q.y, -q.z, q.w); +} + +inline Quaternion Quaternion::CreateFromEulerAngles(float x, float y, float z) +{ + Quaternion qx(sinf(x / 2.0f), 0.0f, 0.0f, cosf(x / 2.0f)); + Quaternion qy(0.0f, sinf(y / 2.0f), 0.0f, cosf(y / 2.0f)); + Quaternion qz(0.0f, 0.0f, sinf(z / 2.0f), cosf(z / 2.0f)); + + return Normalize(qz * qy * qx); +} + +inline Quaternion Quaternion::CreateFromAxisAngle(float angle, const Vector3 &axis) +{ + Quaternion result; + + float c = cosf(angle / 2.0f); + float s = sinf(angle / 2.0f); + + result.w = c; + result.x = axis.x * s; + result.y = axis.y * s; + result.z = axis.z * s; + + return Normalize(result); +} + +inline Quaternion Quaternion::CreateFromRotationMatrix(const Matrix4x4 &matrix) +{ + Quaternion result; + + float n = matrix.m[_11] + matrix.m[_22] + matrix.m[_33]; + if (n > 0.0f) + { + float a = sqrtf(n + 1.0f); + result.w = a / 2.0f; + a = 0.5f / a; + result.x = (matrix.m[_32] - matrix.m[_23]) * a; + result.y = (matrix.m[_13] - matrix.m[_31]) * a; + result.z = (matrix.m[_21] - matrix.m[_12]) * a; + } + else if ((matrix.m[_11] >= matrix.m[_22]) && (matrix.m[_11] >= matrix.m[_33])) + { + float a = sqrtf(1.0f + matrix.m[_11] - matrix.m[_22] - matrix.m[_33]); + float b = 0.5f / a; + + result.x = 0.5f * a; + result.y = (matrix.m[_21] + matrix.m[_12]) * b; + result.z = (matrix.m[_31] + matrix.m[_13]) * b; + result.w = (matrix.m[_32] - matrix.m[_23]) * b; + } + else if (matrix.m[_22] > matrix.m[_33]) + { + float a = sqrtf(1.0f + matrix.m[_22] - matrix.m[_11] - matrix.m[_33]); + float b = 0.5f / a; + + result.x = (matrix.m[_12] + matrix.m[_21]) * b; + result.y = 0.5f * a; + result.z = (matrix.m[_23] + matrix.m[_32]) * b; + result.w = (matrix.m[_13] - matrix.m[_31]) * b; + } + else + { + float a = sqrtf(1.0f + matrix.m[_33] - matrix.m[_11] - matrix.m[_22]); + float b = 0.5f / a; + + result.x = (matrix.m[_13] + matrix.m[_31]) * b; + result.y = (matrix.m[_23] + matrix.m[_32]) * b; + result.z = 0.5f * a; + result.w = (matrix.m[_21] - matrix.m[_12]) * b; + } + + return Normalize(result); +} + +inline Quaternion Quaternion::Cross(const Quaternion &a, const Quaternion &b) +{ + return a * b; +} + +inline float Quaternion::Dot(const Quaternion &a, const Quaternion &b) +{ + return (a.w * b.w) + (a.x * b.x) + (a.y * b.y) + (a.z * b.z); +} + +inline void Quaternion::ExtractAxisAngle(const Quaternion &q, float &angle, Vector3 &axis) +{ + angle = 2.0f * acosf(q.w); + float n = sqrtf(1.0f - (q.w * q.w)); + if (n > 0.0001f) + axis = q.GetVector() / n; + else + axis = X_AXIS; +} + +inline Quaternion Quaternion::Inverse(const Quaternion &q) +{ + float inverseSquaredLength = 1.0f / LengthSquared(q); + return Quaternion( + -q.x * inverseSquaredLength, + -q.y * inverseSquaredLength, + -q.z * inverseSquaredLength, + q.w * inverseSquaredLength + ); +} + +inline float Quaternion::Length(const Quaternion &q) +{ + return sqrtf((q.w * q.w) + (q.x * q.x) + (q.y * q.y) + (q.z * q.z)); +} + +inline float Quaternion::LengthSquared(const Quaternion &q) +{ + return (q.w * q.w) + (q.x * q.x) + (q.y * q.y) + (q.z * q.z); +} + +inline Quaternion Quaternion::Lerp(const Quaternion &a, const Quaternion &b, float interpolation) +{ + return (a * (1.0f - interpolation)) + (b * interpolation); +} + +inline Quaternion Quaternion::Normalize(const Quaternion &q) +{ + float inverseLength = 1.0f / Length(q); + return Quaternion( + q.x * inverseLength, + q.y * inverseLength, + q.z * inverseLength, + q.w * inverseLength + ); +} + +inline Quaternion Quaternion::Slerp(const Quaternion &a, const Quaternion &b, float interpolation) +{ + if (LengthSquared(a) == 0.0f) + { + if (LengthSquared(b) == 0.0f) + return IDENTITY_QUATERNION; + else + return b; + } + else if (LengthSquared(b) == 0.0f) + return a; + + Quaternion q1 = a; + Quaternion q2 = b; + + float cosHalfAngle = q1.w * q2.w + Vector3::Dot(q1.GetVector(), q2.GetVector()); + + if (cosHalfAngle >= 1.0f || cosHalfAngle <= -1.0f) + return q1; + else if (cosHalfAngle < 0.0f) + { + q2.x = -q2.x; + q2.y = -q2.y; + q2.z = -q2.z; + q2.w = -q2.w; + cosHalfAngle = -cosHalfAngle; + } + + float blendA; + float blendB; + if (cosHalfAngle < 0.99f) + { + float halfAngle = acosf(cosHalfAngle); + float sinHalfAngle = sinf(halfAngle); + float oneOverSinHalfAngle = 1.0f / sinHalfAngle; + blendA = sinf(halfAngle * (1.0f - interpolation)) * oneOverSinHalfAngle; + blendB = sinf(halfAngle * interpolation) * oneOverSinHalfAngle; + } + else + { + blendA = 1.0f - interpolation; + blendB = interpolation; + } + + Quaternion result(q1.GetVector() * blendA + q2.GetVector() * blendB, q1.w * blendA + q2.w * blendB); + if (LengthSquared(result) > 0.0f) + return Normalize(result); + else + return IDENTITY_QUATERNION; +} + +inline Quaternion operator+(const Quaternion &left, const Quaternion &right) +{ + return Quaternion( + left.x + right.x, + left.y + right.y, + left.z + right.z, + left.w + right.w + ); +} + +inline Quaternion &operator+=(Quaternion &left, const Quaternion &right) +{ + left = left + right; + return left; +} + +inline Quaternion operator-(const Quaternion &left, const Quaternion &right) +{ + return Quaternion( + left.x - right.x, + left.y - right.y, + left.z - right.z, + left.w - right.w + ); +} + +inline Quaternion &operator-=(Quaternion &left, const Quaternion &right) +{ + left = left - right; + return left; +} + +inline Quaternion operator*(const Quaternion &left, float right) +{ + return Quaternion( + left.x * right, + left.y * right, + left.z * right, + left.w * right + ); +} + +inline Quaternion &operator*=(Quaternion &left, float right) +{ + left = left * right; + return left; +} + +inline Quaternion operator*(const Quaternion &left, const Quaternion &right) +{ + return Quaternion( + (left.w * right.x) + (left.x * right.w) + (left.y * right.z) - (left.z * right.y), + (left.w * right.y) + (left.y * right.w) + (left.z * right.x) - (left.x * right.z), + (left.w * right.z) + (left.z * right.w) + (left.x * right.y) - (left.y * right.x), + (left.w * right.w) - (left.x * right.x) - (left.y * right.y) - (left.z * right.z) + ); +} + +inline Quaternion &operator*=(Quaternion &left, const Quaternion &right) +{ + left = left * right; + return left; +} + +inline Quaternion operator/(const Quaternion &left, float right) +{ + return Quaternion( + left.x / right, + left.y / right, + left.z / right, + left.w / right + ); +} + +inline Quaternion &operator/=(Quaternion &left, float right) +{ + left = left / right; + return left; +} + +inline Vector3 operator*(const Vector3 &left, const Quaternion &right) +{ + return Vector3( + ((left.x * ((1.0f - (right.y * (right.y + right.y))) - (right.z * (right.z + right.z)))) + (left.y * ((right.x * (right.y + right.y)) - (right.w * (right.z + right.z))))) + (left.z * ((right.x * (right.z + right.z)) + (right.w * (right.y + right.y)))), + ((left.x * ((right.x * (right.y + right.y)) + (right.w * (right.z + right.z)))) + (left.y * ((1.0f - (right.x * (right.x + right.x))) - (right.z * (right.z + right.z))))) + (left.z * ((right.y * (right.z + right.z)) - (right.w * (right.x + right.x)))), + ((left.x * ((right.x * (right.z + right.z)) - (right.w * (right.y + right.y)))) + (left.y * ((right.y * (right.z + right.z)) + (right.w * (right.x + right.x))))) + (left.z * ((1.0f - (right.x * (right.x + right.x))) - (right.y * (right.y + right.y)))) + ); +} + +#endif + diff --git a/src/framework/math/ray.h b/src/framework/math/ray.h new file mode 100644 index 0000000..12f6cce --- /dev/null +++ b/src/framework/math/ray.h @@ -0,0 +1,70 @@ +#ifndef __FRAMEWORK_MATH_RAY_H_INCLUDED__ +#define __FRAMEWORK_MATH_RAY_H_INCLUDED__ + +#include "vector3.h" + +/** + * Represents a ray in 3D space originating from a point and pointing + * in a (normalized) direction. + */ +struct Ray +{ + /** + * Creates a ray starting at the origin with zero length. + */ + Ray(); + + /** + * Creates a ray with the specified properties. + * @param position the origin position of the ray + * @param direction the normalized direction vector of the ray + */ + Ray(const Vector3 &position, const Vector3 &direction); + + /** + * Creates a ray with the specified properties. + * @param positionX the X coordinate of the origin position of the ray + * @param positionY the Y coordinate of the origin position of the ray + * @param positionZ the Z coordinate of the origin position of the ray + * @param directionX the X coordinate of the normalized direction vector of the ray + * @param directionY the Y coordinate of the normalized direction vector of the ray + * @param directionZ the Z coordinate of the normalized direction vector of the ray + */ + Ray(float positionX, float positionY, float positionZ, float directionX, float directionY, float directionZ); + + /** + * Returns the point along the ray at given distance from the ray's origin. + * @param distance distance from the ray's origin + * @return Vector3 the point that is located the specified distance from the ray's origin + */ + Vector3 GetPositionAt(float distance) const; + + Vector3 position; + Vector3 direction; +}; + +inline Ray::Ray() +{ + position = ZERO_VECTOR; + direction = ZERO_VECTOR; +} + +inline Ray::Ray(const Vector3 &position, const Vector3 &direction) +{ + this->position = position; + this->direction = direction; +} + +inline Ray::Ray(float positionX, float positionY, float positionZ, float directionX, float directionY, float directionZ) +{ + this->position = Vector3(positionX, positionY, positionZ); + this->direction = Vector3(directionX, directionY, directionZ); +} + +inline Vector3 Ray::GetPositionAt(float distance) const +{ + return (this->direction * distance) + this->position; +} + +#endif + diff --git a/src/framework/math/rect.h b/src/framework/math/rect.h new file mode 100644 index 0000000..7b027d3 --- /dev/null +++ b/src/framework/math/rect.h @@ -0,0 +1,97 @@ +#ifndef __FRAMEWORK_MATH_RECT_H_INCLUDED__ +#define __FRAMEWORK_MATH_RECT_H_INCLUDED__ + +#include "../common.h" + +/** + * Represents a 2D rectangle using integers for the coordinates. + */ +struct Rect +{ + /** + * Creates an uninitialized rect. + */ + Rect(); + + /** + * Creates a rect with the specified properties. + * @param left left X coordinate + * @param top top Y coordinate + * @param right right X coordinate + * @param bottom bottom Y coordinate + */ + Rect(int32_t left, int32_t top, int32_t right, int32_t bottom); + + /** + * Sets new rect dimensions. + * @param left new left X coordinate + * @param top new top Y coordinate + * @param right new right X coordinate + * @param bottom new bottom Y coordinate + */ + void Set(int32_t left, int32_t top, int32_t right, int32_t bottom); + + /** + * Tests if a point is contained inside this rectangle. + * @param x x coordinate of the point to test + * @param y y coordinate of the point to test + * @return TRUE if the point is contained, FALSE if not + */ + BOOL Contains(int32_t x, int32_t y) const; + + /** + * @return the rect's width + */ + int32_t GetWidth() const; + + /** + * @return the rect's height + */ + int32_t GetHeight() const; + + int32_t left; + int32_t top; + int32_t right; + int32_t bottom; +}; + +inline Rect::Rect() +{ +} + +inline Rect::Rect(int32_t left, int32_t top, int32_t right, int32_t bottom) +{ + this->left = left; + this->top = top; + this->right = right; + this->bottom = bottom; +} + +inline void Rect::Set(int32_t left, int32_t top, int32_t right, int32_t bottom) +{ + this->left = left; + this->top = top; + this->right = right; + this->bottom = bottom; +} + +inline BOOL Rect::Contains(int32_t x, int32_t y) const +{ + if (x >= left && y >= top && x <= right && y <= bottom) + return TRUE; + else + return FALSE; +} + +inline int32_t Rect::GetWidth() const +{ + return right - left; +} + +inline int32_t Rect::GetHeight() const +{ + return bottom - top; +} + +#endif + diff --git a/src/framework/math/rectf.h b/src/framework/math/rectf.h new file mode 100644 index 0000000..e860600 --- /dev/null +++ b/src/framework/math/rectf.h @@ -0,0 +1,95 @@ +#ifndef __FRAMEWORK_MATH_RECTF_H_INCLUDED__ +#define __FRAMEWORK_MATH_RECTF_H_INCLUDED__ + +/** + * Represents a 2D rectangle using floats for the coordinates. + */ +struct RectF +{ + /** + * Creates an uninitialized rect. + */ + RectF(); + + /** + * Creates a rect with the specified properties. + * @param left left X coordinate + * @param top top Y coordinate + * @param right right X coordinate + * @param bottom bottom Y coordinate + */ + RectF(float left, float top, float right, float bottom); + + /** + * Sets new rect dimensions. + * @param left new left X coordinate + * @param top new top Y coordinate + * @param right new right X coordinate + * @param bottom new bottom Y coordinate + */ + void Set(float left, float top, float right, float bottom); + + /** + * Tests if a point is contained inside this rectangle. + * @param x x coordinate of the point to test + * @param y y coordinate of the point to test + * @return BOOL TRUE if the point is contained, FALSE if not + */ + BOOL Contains(float x, float y) const; + + /** + * @return the rect's width + */ + float GetWidth() const; + + /** + * @return the rect's height + */ + float GetHeight() const; + + float left; + float top; + float right; + float bottom; +}; + +inline RectF::RectF() +{ +} + +inline RectF::RectF(float left, float top, float right, float bottom) +{ + this->left = left; + this->top = top; + this->right = right; + this->bottom = bottom; +} + +inline void RectF::Set(float left, float top, float right, float bottom) +{ + this->left = left; + this->top = top; + this->right = right; + this->bottom = bottom; +} + +inline BOOL RectF::Contains(float x, float y) const +{ + if (x >= left && y >= top && x <= right && y <= bottom) + return TRUE; + else + return FALSE; +} + +inline float RectF::GetWidth() const +{ + return right - left; +} + +inline float RectF::GetHeight() const +{ + return bottom - top; +} + +#endif + diff --git a/src/framework/math/vector2.h b/src/framework/math/vector2.h new file mode 100644 index 0000000..1ae1215 --- /dev/null +++ b/src/framework/math/vector2.h @@ -0,0 +1,293 @@ +#ifndef __FRAMEWORK_VECTOR2_H_INCLUDED__ +#define __FRAMEWORK_VECTOR2_H_INCLUDED__ + +#include "../common.h" +#include + +/** + * Represents a 2D vector and provides common methods for vector math. + *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • http://www.dhpoware.com/source/mathlib.html
    • + *
+ */ +struct Vector2 +{ + /** + * Creates an uninitialized vector. + */ + Vector2(); + + /** + * Creates a vector with the specified properties. + * @param x X coordinate of the vector + * @param y Y coordinate of the vector + */ + Vector2(float x, float y); + + /** + * Creates a vector with the specified properties. + * @param v an array with 2 values that will be used as this vector's components + */ + Vector2(const float *v); + + /** + * Sets new coordinates for this vector. + * @param x new X coordinate of the vector + * @param y new Y coordinate of the vector + */ + void Set(float x, float y); + + /** + * Sets new coordinates for this vector. + * @param v another vector whose coordinates are to be copied and used for this vector + */ + void Set(const Vector2 &v); + + /** + * Calculates the distance between two points. + * @param a the first point + * @param b the second point + * @return the distance between both points + */ + static float Distance(const Vector2 &a, const Vector2 &b); + + /** + * Calculates the squared distance between two points (the distance minus + * the sqrt call). + * @param a the first point + * @param b the second point + * @return the squared distance between both points + */ + static float DistanceSquared(const Vector2 &a, const Vector2 &b); + + /** + * Computes the dot product of 2 vectors. + * @param a first vector + * @param b second vector + * @return the dot product + */ + static float Dot(const Vector2 &a, const Vector2 &b); + + /** + * Returns the length (magnitude) of a vector. + * @param v vector to calculate the length of + * @return the vector length + */ + static float Length(const Vector2 &v); + + /** + * Returns the squared length of a vector (the magnitude minus the sqrt + * call). + * @param v vector to calculate the squared length of + * @return squared length of the vector + */ + static float LengthSquared(const Vector2 &v); + + /** + * Normalizes a vector. + * @param v vector to normalize + * @return the normalized vector + */ + static Vector2 Normalize(const Vector2 &v); + + /** + * Adjusts a vector so that it's length is equal to the given length. + * @param v the original vector to be adjusted + * @param length desired vector length (magnitude) + * @return the resulting vector after it's length has been converted to the + * desired amount + */ + static Vector2 SetLength(const Vector2 &v, float length); + + float x; + float y; +}; + +#define ZERO_VECTOR2 Vector2(0.0f, 0.0f) + +bool operator==(const Vector2 &left, const Vector2 &right); +Vector2 operator-(const Vector2 &left); +Vector2 operator+(const Vector2 &left, const Vector2 &right); +Vector2 &operator+=(Vector2 &left, const Vector2 &right); +Vector2 operator-(const Vector2 &left, const Vector2 &right); +Vector2 &operator-=(Vector2 &left, const Vector2 &right); +Vector2 operator*(const Vector2 &left, float right); +Vector2 &operator*=(Vector2 &left, float right); +Vector2 operator/(const Vector2 &left, float right); +Vector2 &operator/=(Vector2 &left, float right); +Vector2 operator*(const Vector2 &left, const Vector2 &right); +Vector2 &operator*=(Vector2 &left, const Vector2 &right); +Vector2 operator/(const Vector2 &left, const Vector2 &right); +Vector2 &operator/=(Vector2 &left, const Vector2 &right); + +inline Vector2::Vector2() +{ +} + +inline Vector2::Vector2(float x, float y) +{ + this->x = x; + this->y = y; +} + +inline Vector2::Vector2(const float *v) +{ + x = v[0]; + y = v[1]; +} + +inline void Vector2::Set(float x, float y) +{ + this->x = x; + this->y = y; +} + +inline void Vector2::Set(const Vector2 &v) +{ + this->x = v.x; + this->y = v.y; +} + +inline float Vector2::Distance(const Vector2 &a, const Vector2 &b) +{ + return sqrtf( + ((b.x - a.x) * (b.x - a.x)) + + ((b.y - a.y) * (b.y - a.y)) + ); +} + +inline float Vector2::DistanceSquared(const Vector2 &a, const Vector2 &b) +{ + return + ((b.x - a.x) * (b.x - a.x)) + + ((b.y - a.y) * (b.y - a.y)); +} + +inline float Vector2::Dot(const Vector2 &a, const Vector2 &b) +{ + return + (a.x * b.y) + + (a.y * b.y); +} + +inline float Vector2::Length(const Vector2 &v) +{ + return sqrtf( + (v.x * v.x) + + (v.y * v.y) + ); +} + +inline float Vector2::LengthSquared(const Vector2 &v) +{ + return + (v.x * v.x) + + (v.y * v.y); +} + +inline Vector2 Vector2::Normalize(const Vector2 &v) +{ + float inverseLength = 1.0f / Length(v); + return Vector2( + v.x * inverseLength, + v.y * inverseLength + ); +} + +inline Vector2 Vector2::SetLength(const Vector2 &v, float length) +{ + return v * (length / Length(v)); +} + +inline bool operator==(const Vector2 &left, const Vector2 &right) +{ + return (left.x == right.x && left.y == right.y); +} + +inline Vector2 operator-(const Vector2 &left) +{ + return Vector2(-left.x, -left.y); +} + +inline Vector2 operator+(const Vector2 &left, const Vector2 &right) +{ + return Vector2(left.x + right.x, left.y + right.y); +} + +inline Vector2 &operator+=(Vector2 &left, const Vector2 &right) +{ + left.x += right.x; + left.y += right.y; + + return left; +} + +inline Vector2 operator-(const Vector2 &left, const Vector2 &right) +{ + return Vector2(left.x - right.x, left.y - right.y); +} + +inline Vector2 &operator-=(Vector2 &left, const Vector2 &right) +{ + left.x -= right.x; + left.y -= right.y; + + return left; +} + +inline Vector2 operator*(const Vector2 &left, float right) +{ + return Vector2(left.x * right, left.y * right); +} + +inline Vector2 &operator*=(Vector2 &left, float right) +{ + left.x *= right; + left.y *= right; + + return left; +} + +inline Vector2 operator/(const Vector2 &left, float right) +{ + return Vector2(left.x / right, left.y / right); +} + +inline Vector2 &operator/=(Vector2 &left, float right) +{ + left.x /= right; + left.y /= right; + + return left; +} + +inline Vector2 operator*(const Vector2 &left, const Vector2 &right) +{ + return Vector2(left.x * right.x, left.y * right.y); +} + +inline Vector2 &operator*=(Vector2 &left, const Vector2 &right) +{ + left.x *= right.x; + left.y *= right.y; + + return left; +} + +inline Vector2 operator/(const Vector2 &left, const Vector2 &right) +{ + return Vector2(left.x / right.x, left.y / right.y); +} + +inline Vector2 &operator/=(Vector2 &left, const Vector2 &right) +{ + left.x /= right.x; + left.y /= right.y; + + return left; +} + +#endif + diff --git a/src/framework/math/vector3.h b/src/framework/math/vector3.h new file mode 100644 index 0000000..174a26e --- /dev/null +++ b/src/framework/math/vector3.h @@ -0,0 +1,404 @@ +#ifndef __FRAMEWORK_VECTOR3_H_INCLUDED__ +#define __FRAMEWORK_VECTOR3_H_INCLUDED__ + +#include "../common.h" +#include + +/** + *

Represents a 3D vector and provides common methods for vector math.

+ *

Referenced/based on code from:

+ *
    + *
  • 3D Math Primer for Graphics and Game Development (Dunn & Parberry, 2002)
    • + *
  • http://www.dhpoware.com/source/mathlib.html
    • + *
  • http://www.peroxide.dk/papers/collision/collision.pdf
    • + *
+ */ +struct Vector3 +{ + /** + * Creates an uninitialized vector. + */ + Vector3(); + + /** + * Creates a vector with the specified properties. + * @param x X coordinate of the vector + * @param y Y coordinate of the vector + * @param z Z coordinate of the vector + */ + Vector3(float x, float y, float z); + + /** + * Creates a vector with the specified properties. + * @param v an array with 3 values that will be used as this vector's components + */ + Vector3(const float *v); + + /** + * Sets new coordinates for this vector. + * @param x new X coordinate of the vector + * @param y new Y coordinate of the vector + * @param z new Z coordinate of the vector + */ + void Set(float x, float y, float z); + + /** + * Sets new coordinates for this vector. + * @param v another vector whose coordinates are to be copied and used for this vector + */ + void Set(const Vector3 &v); + + /** + * Computes the cross product of 2 vectors. + * @param a first vector + * @param b second vector + * @return the cross product + */ + static Vector3 Cross(const Vector3 &a, const Vector3 &b); + + /** + * Calculates the distance between two points. + * @param a the first point + * @param b the second point + * @return the distance between both points + */ + static float Distance(const Vector3 &a, const Vector3 &b); + + /** + * Calculates the squared distance between two points (the distance minus + * the sqrt call). + * @param a the first point + * @param b the second point + * @return the squared distance between both points + */ + static float DistanceSquared(const Vector3 &a, const Vector3 &b); + + /** + * Computes the dot product of 2 vectors. + * @param a first vector + * @param b second vector + * @return the dot product + */ + static float Dot(const Vector3 &a, const Vector3 &b); + + /** + * Checks if a given point lies inside a triangle or not. + * @param point point to test + * @param a first vector of the triangle + * @param b second vector of the triangle + * @param c third vector of the triangle + * @return TRUE if the point lies inside the triangle + */ + static BOOL IsPointInTriangle(const Vector3 &point, const Vector3 &a, const Vector3 &b, const Vector3 &c); + + /** + * Returns the length (magnitude) of a vector. + * @param v vector to calculate the length of + * @return the vector length + */ + static float Length(const Vector3 &v); + + /** + * Returns the squared length of a vector (the magnitude minus the sqrt + * call). + * @param v vector to calculate the squared length of + * @return squared length of the vector + */ + static float LengthSquared(const Vector3 &v); + + /** + * Linearly interpolates between two vectors. + * @param a the first vector + * @param b the second vector + * @param interpolation the amount to interpolate + * @return Vector3 the interpolated vector + */ + static Vector3 Lerp(const Vector3 &a, const Vector3 &b, float interpolation); + + /** + * Normalizes a vector. + * @param v vector to normalize + * @return the normalized vector + */ + static Vector3 Normalize(const Vector3 &v); + + /** + * Adjusts a vector so that it's length is equal to the given + * length. + * @param v the original vector to be adjusted + * @param length desired vector length (magnitude) + * @return the resulting vector after it's length has been converted to the + * desired amount + */ + static Vector3 SetLength(const Vector3 &v, float length); + + /** + * Calculates a normal vector for the given 3 vectors making up a + * triangle (counter clockwise order). + * @param a first vertex + * @param b second vertex + * @param c third vertex + * @return normal vector for the triangle + */ + static Vector3 SurfaceNormal(const Vector3 &a, const Vector3 &b, const Vector3 &c); + + float x; + float y; + float z; +}; + +bool operator==(const Vector3 &left, const Vector3 &right); +Vector3 operator-(const Vector3 &left); +Vector3 operator+(const Vector3 &left, const Vector3 &right); +Vector3 &operator+=(Vector3 &left, const Vector3 &right); +Vector3 operator-(const Vector3 &left, const Vector3 &right); +Vector3 &operator-=(Vector3 &left, const Vector3 &right); +Vector3 operator*(const Vector3 &left, float right); +Vector3 &operator*=(Vector3 &left, float right); +Vector3 operator/(const Vector3 &left, float right); +Vector3 &operator/=(Vector3 &left, float right); +Vector3 operator*(const Vector3 &left, const Vector3 &right); +Vector3 &operator*=(Vector3 &left, const Vector3 &right); +Vector3 operator/(const Vector3 &left, const Vector3 &right); +Vector3 &operator/=(Vector3 &left, const Vector3 &right); + +#define ZERO_VECTOR Vector3(0.0f, 0.0f, 0.0f) +#define X_AXIS Vector3(1.0f, 0.0f, 0.0f) +#define Y_AXIS Vector3(0.0f, 1.0f, 0.0f) +#define Z_AXIS Vector3(0.0f, 0.0f, 1.0f) +#define UP Vector3(0.0f, 1.0f, 0.0f) +#define DOWN Vector3(0.0f, -1.0f, 0.0f) +#define FORWARD Vector3(0.0f, 0.0f, -1.0f) +#define BACKWARD Vector3(0.0f, 0.0f, 1.0f) +#define LEFT Vector3(-1.0f, 0.0f, 0.0f) +#define RIGHT Vector3(1.0f, 0.0f, 0.0f) + +inline Vector3::Vector3() +{ +} + +inline Vector3::Vector3(float x, float y, float z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +inline Vector3::Vector3(const float *v) +{ + x = v[0]; + y = v[1]; + z = v[2]; +} + +inline void Vector3::Set(float x, float y, float z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +inline void Vector3::Set(const Vector3 &v) +{ + this->x = v.x; + this->y = v.y; + this->z = v.z; +} + +inline Vector3 Vector3::Cross(const Vector3 &a, const Vector3 &b) +{ + return Vector3( + (a.y * b.z) - (a.z * b.y), + (a.z * b.x) - (a.x * b.z), + (a.x * b.y) - (a.y * b.x) + ); +} + +inline float Vector3::Distance(const Vector3 &a, const Vector3 &b) +{ + return sqrtf( + ((b.x - a.x) * (b.x - a.x)) + + ((b.y - a.y) * (b.y - a.y)) + + ((b.z - a.z) * (b.z - a.z)) + ); +} + +inline float Vector3::DistanceSquared(const Vector3 &a, const Vector3 &b) +{ + return + ((b.x - a.x) * (b.x - a.x)) + + ((b.y - a.y) * (b.y - a.y)) + + ((b.z - a.z) * (b.z - a.z)); +} + +inline float Vector3::Dot(const Vector3 &a, const Vector3 &b) +{ + return + (a.x * b.x) + + (a.y * b.y) + + (a.z * b.z); +} + +inline BOOL Vector3::IsPointInTriangle(const Vector3 &point, const Vector3 &a, const Vector3 &b, const Vector3 &c) +{ + Vector3 v0 = c - a; + Vector3 v1 = b - a; + Vector3 v2 = point - a; + + float dot00 = (v0.x * v0.x) + (v0.y * v0.y) + (v0.z * v0.z); + float dot01 = (v0.x * v1.x) + (v0.y * v1.y) + (v0.z * v1.z); + float dot02 = (v0.x * v2.x) + (v0.y * v2.y) + (v0.z * v2.z); + float dot11 = (v1.x * v1.x) + (v1.y * v1.y) + (v1.z * v1.z); + float dot12 = (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z); + + float denom = dot00 * dot11 - dot01 * dot01; + if (denom == 0) + return FALSE; + + float u = (dot11 * dot02 - dot01 * dot12) / denom; + float v = (dot00 * dot12 - dot01 * dot02) / denom; + + if (u >= 0 && v >= 0 && u + v <= 1) + return TRUE; + else + return FALSE; +} + +inline float Vector3::Length(const Vector3 &v) +{ + return sqrtf( + (v.x * v.x) + + (v.y * v.y) + + (v.z * v.z) + ); +} + +inline float Vector3::LengthSquared(const Vector3 &v) +{ + return + (v.x * v.x) + + (v.y * v.y) + + (v.z * v.z); +} + +inline Vector3 Vector3::Lerp(const Vector3 &a, const Vector3 &b, float interpolation) +{ + return a + (b - a) * interpolation; +} + +inline Vector3 Vector3::Normalize(const Vector3 &v) +{ + float inverseLength = 1.0f / Length(v); + return Vector3( + v.x * inverseLength, + v.y * inverseLength, + v.z * inverseLength + ); +} + +inline Vector3 Vector3::SetLength(const Vector3 &v, float length) +{ + return v * (length / Length(v)); +} + +inline Vector3 Vector3::SurfaceNormal(const Vector3 &a, const Vector3 &b, const Vector3 &c) +{ + return Normalize(Cross((b - a), (c - a))); +} + +inline bool operator==(const Vector3 &left, const Vector3 &right) +{ + return (left.x == right.x && left.y == right.y && left.z == right.z); +} + +inline Vector3 operator-(const Vector3 &left) +{ + return Vector3(-left.x, -left.y, -left.z); +} + +inline Vector3 operator+(const Vector3 &left, const Vector3 &right) +{ + return Vector3(left.x + right.x, left.y + right.y, left.z + right.z); +} + +inline Vector3 &operator+=(Vector3 &left, const Vector3 &right) +{ + left.x += right.x; + left.y += right.y; + left.z += right.z; + + return left; +} + +inline Vector3 operator-(const Vector3 &left, const Vector3 &right) +{ + return Vector3(left.x - right.x, left.y - right.y, left.z - right.z); +} + +inline Vector3 &operator-=(Vector3 &left, const Vector3 &right) +{ + left.x -= right.x; + left.y -= right.y; + left.z -= right.z; + + return left; +} + +inline Vector3 operator*(const Vector3 &left, float right) +{ + return Vector3(left.x * right, left.y * right, left.z * right); +} + +inline Vector3 &operator*=(Vector3 &left, float right) +{ + left.x *= right; + left.y *= right; + left.z *= right; + + return left; +} + +inline Vector3 operator/(const Vector3 &left, float right) +{ + return Vector3(left.x / right, left.y / right, left.z / right); +} + +inline Vector3 &operator/=(Vector3 &left, float right) +{ + left.x /= right; + left.y /= right; + left.z /= right; + + return left; +} + +inline Vector3 operator*(const Vector3 &left, const Vector3 &right) +{ + return Vector3(left.x * right.x, left.y * right.y, left.z * right.z); +} + +inline Vector3 &operator*=(Vector3 &left, const Vector3 &right) +{ + left.x *= right.x; + left.y *= right.y; + left.z *= right.z; + + return left; +} + +inline Vector3 operator/(const Vector3 &left, const Vector3 &right) +{ + return Vector3(left.x / right.x, left.y / right.y, left.z / right.z); +} + +inline Vector3 &operator/=(Vector3 &left, const Vector3 &right) +{ + left.x /= right.x; + left.y /= right.y; + left.z /= right.z; + + return left; +} + +#endif + diff --git a/src/framework/math/vector4.h b/src/framework/math/vector4.h new file mode 100644 index 0000000..6981c84 --- /dev/null +++ b/src/framework/math/vector4.h @@ -0,0 +1,331 @@ +#ifndef __FRAMEWORK_VECTOR4_H_INCLUDED__ +#define __FRAMEWORK_VECTOR4_H_INCLUDED__ + +#include "../common.h" +#include + +/** + * Represents a 4D vector and provides common methods for vector math. + * Referenced/based on code from: + */ +struct Vector4 +{ + /** + * Creates an uninitialized vector. + */ + Vector4(); + + /** + * Creates a vector with the specified properties. + * @param x X coordinate of the vector + * @param y Y coordinate of the vector + * @param z Z coordinate of the vector + * @param w W coordinate of the vector + */ + Vector4(float x, float y, float z, float w); + + /** + * Creates a vector with the specified properties. + * @param v an array with 4 values that will be used as this vector's components + */ + Vector4(const float *v); + + /** + * Sets new coordinates for this vector. + * @param x new X coordinate of the vector + * @param y new Y coordinate of the vector + * @param z new Z coordinate of the vector + * @param w new W coordinate of the vector + */ + void Set(float x, float y, float z, float w); + + /** + * Sets new coordinates for this vector. + * @param v another vector whose coordinates are to be copied and used for this vector + */ + void Set(const Vector4 &v); + + /** + * Calculates the distance between two points. + * @param a the first point + * @param b the second point + * @return the distance between both points + */ + static float Distance(const Vector4 &a, const Vector4 &b); + + /** + * Calculates the squared distance between two points (the distance minus + * the sqrt call). + * @param a the first point + * @param b the second point + * @return the squared distance between both points + */ + static float DistanceSquared(const Vector4 &a, const Vector4 &b); + + /** + * Computes the dot product of 2 vectors. + * @param a first vector + * @param b second vector + * @return the dot product + */ + static float Dot(const Vector4 &a, const Vector4 &b); + + /** + * Returns the length (magnitude) of a vector. + * @param v vector to calculate the length of + * @return the vector length + */ + static float Length(const Vector4 &v); + + /** + * Returns the squared length of a vector (the magnitude minus the sqrt + * call). + * @param v vector to calculate the squared length of + * @return squared length of the vector + */ + static float LengthSquared(const Vector4 &v); + + /** + * Linearly interpolates between two vectors. + * @param a the first vector + * @param b the second vector + * @param interpolation the amount to interpolate + * @return Vector3 the interpolated vector + */ + static Vector4 Lerp(const Vector4 &a, const Vector4 &b, float interpolation); + + /** + * Normalizes a vector. + * @param v vector to normalize + * @return the normalized vector + */ + static Vector4 Normalize(const Vector4 &v); + + /** + * Adjusts a vector so that it's length is equal to the given + * length. + * @param v the original vector to be adjusted + * @param length desired vector length (magnitude) + * @return the resulting vector after it's length has been converted to the + * desired amount + */ + static Vector4 SetLength(const Vector4 &v, float length); + + float x; + float y; + float z; + float w; +}; + +bool operator==(const Vector4 &left, const Vector4 &right); +Vector4 operator-(const Vector4 &left); +Vector4 operator+(const Vector4 &left, const Vector4 &right); +Vector4 &operator+=(Vector4 &left, const Vector4 &right); +Vector4 operator-(const Vector4 &left, const Vector4 &right); +Vector4 &operator-=(Vector4 &left, const Vector4 &right); +Vector4 operator*(const Vector4 &left, float right); +Vector4 &operator*=(Vector4 &left, float right); +Vector4 operator/(const Vector4 &left, float right); +Vector4 &operator/=(Vector4 &left, float right); +Vector4 operator*(const Vector4 &left, const Vector4 &right); +Vector4 &operator*=(Vector4 &left, const Vector4 &right); +Vector4 operator/(const Vector4 &left, const Vector4 &right); +Vector4 &operator/=(Vector4 &left, const Vector4 &right); + +inline Vector4::Vector4() +{ +} + +inline Vector4::Vector4(float x, float y, float z, float w) +{ + this->x = x; + this->y = y; + this->z = z; + this->w = w; +} + +inline Vector4::Vector4(const float *v) +{ + x = v[0]; + y = v[1]; + z = v[2]; + w = v[3]; +} + +inline void Vector4::Set(float x, float y, float z, float w) +{ + this->x = x; + this->y = y; + this->z = z; + this->w = w; +} + +inline void Vector4::Set(const Vector4 &v) +{ + this->x = v.x; + this->y = v.y; + this->z = v.z; + this->w = v.w; +} + +inline float Vector4::Distance(const Vector4 &a, const Vector4 &b) +{ + return Vector4::Length(b - a); +} + +inline float Vector4::DistanceSquared(const Vector4 &a, const Vector4 &b) +{ + return Vector4::LengthSquared(b - a); +} + +inline float Vector4::Dot(const Vector4 &a, const Vector4 &b) +{ + return + (a.x * b.x) + + (a.y * b.y) + + (a.z * b.z) + + (a.w * b.w); +} + +inline float Vector4::Length(const Vector4 &v) +{ + return sqrtf( + (v.x * v.x) + + (v.y * v.y) + + (v.z * v.z) + + (v.w * v.w) + ); +} + +inline float Vector4::LengthSquared(const Vector4 &v) +{ + return + (v.x * v.x) + + (v.y * v.y) + + (v.z * v.z) + + (v.w * v.w); +} + +inline Vector4 Vector4::Lerp(const Vector4 &a, const Vector4 &b, float interpolation) +{ + return a + (b - a) * interpolation; +} + +inline Vector4 Vector4::Normalize(const Vector4 &v) +{ + float inverseLength = 1.0f / Length(v); + return Vector4( + v.x * inverseLength, + v.y * inverseLength, + v.z * inverseLength, + v.w * inverseLength + ); +} + +inline Vector4 Vector4::SetLength(const Vector4 &v, float length) +{ + return v * (length / Length(v)); +} + +inline bool operator==(const Vector4 &left, const Vector4 &right) +{ + return (left.x == right.x && left.y == right.y && left.z == right.z && left.w == right.w); +} + +inline Vector4 operator-(const Vector4 &left) +{ + return Vector4(-left.x, -left.y, -left.z, -left.w); +} + +inline Vector4 operator+(const Vector4 &left, const Vector4 &right) +{ + return Vector4(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); +} + +inline Vector4 &operator+=(Vector4 &left, const Vector4 &right) +{ + left.x += right.x; + left.y += right.y; + left.z += right.z; + left.w += right.w; + + return left; +} + +inline Vector4 operator-(const Vector4 &left, const Vector4 &right) +{ + return Vector4(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); +} + +inline Vector4 &operator-=(Vector4 &left, const Vector4 &right) +{ + left.x -= right.x; + left.y -= right.y; + left.z -= right.z; + left.w -= right.w; + + return left; +} + +inline Vector4 operator*(const Vector4 &left, float right) +{ + return Vector4(left.x * right, left.y * right, left.z * right, left.w * right); +} + +inline Vector4 &operator*=(Vector4 &left, float right) +{ + left.x *= right; + left.y *= right; + left.z *= right; + left.w *= right; + + return left; +} + +inline Vector4 operator/(const Vector4 &left, float right) +{ + return Vector4(left.x / right, left.y / right, left.z / right, left.w / right); +} + +inline Vector4 &operator/=(Vector4 &left, float right) +{ + left.x /= right; + left.y /= right; + left.z /= right; + left.w /= right; + + return left; +} + +inline Vector4 operator*(const Vector4 &left, const Vector4 &right) +{ + return Vector4(left.x * right.x, left.y * right.y, left.z * right.z, left.w * right.w); +} + +inline Vector4 &operator*=(Vector4 &left, const Vector4 &right) +{ + left.x *= right.x; + left.y *= right.y; + left.z *= right.z; + left.w *= right.w; + + return left; +} + +inline Vector4 operator/(const Vector4 &left, const Vector4 &right) +{ + return Vector4(left.x / right.x, left.y / right.y, left.z / right.z, left.w / right.w); +} + +inline Vector4 &operator/=(Vector4 &left, const Vector4 &right) +{ + left.x /= right.x; + left.y /= right.y; + left.z /= right.z; + left.w /= right.w; + + return left; +} + +#endif + diff --git a/src/framework/math/worldposition.h b/src/framework/math/worldposition.h new file mode 100644 index 0000000..4e2a7ce --- /dev/null +++ b/src/framework/math/worldposition.h @@ -0,0 +1,111 @@ +#ifndef __FRAMEWORK_MATH_WORLDPOSITION_H_INCLUDED__ +#define __FRAMEWORK_MATH_WORLDPOSITION_H_INCLUDED__ + +#include "vector3.h" +#include "matrix4x4.h" + +/** + * Represents a "world position" in 3D space using a matrix with methods + * to modify this position. + */ +struct WorldPosition +{ + /** + * Creates a new world position object with an initial position + * at the origin. + */ + WorldPosition(); + + /** + * Reset the position to the origin. + */ + void Reset(); + + /** + * Rotate around the given axis by a given angle. + * @param angle the angle to rotate by in radians + * @param axisX the x component of the axis to rotate around + * @param axisY the y component of the axis to rotate around + * @param axisZ the z component of the axis to rotate around + */ + void Rotate(float angle, float axisX, float axisY, float axisZ); + + /** + * Rotate around the given axis by a given angle. + * @param angle the angle to rotate by in radians + * @param axis the axis to rotate around + */ + void Rotate(float angle, const Vector3 &axis); + + /** + * Scale by a given amount along each axis. + * @param x amount to scale by along the X axis + * @param y amount to scale by along the Y axis + * @param z amount to scale by along the Z axis + */ + void Scale(float x, float y, float z); + + /** + * Scale by a given amount along each axis. + * @param v amount to scale by along the X, Y and Z axis + */ + void Scale(const Vector3 &v); + + /** + * Translate by a given amount along each axis. + * @param x amount to translate by along the X axis + * @param y amount to translate by along the Y axis + * @param z amount to translate by along the Z axis + */ + void Translate(float x, float y, float z); + + /** + * Translate by a given amount along each axis. + * @param v amount to translate by along the X, Y and Z axis + */ + void Translate(const Vector3 &v); + + Matrix4x4 current; +}; + +inline WorldPosition::WorldPosition() +{ + Reset(); +} + +inline void WorldPosition::Reset() +{ + current = IDENTITY_MATRIX; +} + +inline void WorldPosition::Rotate(float angle, float axisX, float axisY, float axisZ) +{ + current *= Matrix4x4::CreateRotation(angle, Vector3(axisX, axisY, axisZ)); +} + +inline void WorldPosition::Rotate(float angle, const Vector3 &axis) +{ + current *= Matrix4x4::CreateRotation(angle, axis); +} + +inline void WorldPosition::Scale(float x, float y, float z) +{ + current *= Matrix4x4::CreateScale(x, y, z); +} + +inline void WorldPosition::Scale(const Vector3 &v) +{ + current *= Matrix4x4::CreateScale(v.x, v.y, v.z); +} + +inline void WorldPosition::Translate(float x, float y, float z) +{ + current *= Matrix4x4::CreateTranslation(x, y, z); +} + +inline void WorldPosition::Translate(const Vector3 &v) +{ + current *= Matrix4x4::CreateTranslation(v.x, v.y, v.z); +} + +#endif diff --git a/src/framework/operatingsystem.h b/src/framework/operatingsystem.h new file mode 100644 index 0000000..c80ed19 --- /dev/null +++ b/src/framework/operatingsystem.h @@ -0,0 +1,103 @@ +#ifndef __FRAMEWORK_OPERATINGSYSTEM_H_INCLUDED__ +#define __FRAMEWORK_OPERATINGSYSTEM_H_INCLUDED__ + +#include "common.h" + +class BaseGameApp; +class FileSystem; +class GameWindow; +class Mouse; +class Keyboard; +class Touchscreen; +struct GameWindowParams; + +/** + * Interface for an operating system management class which handles + * low level, non-graphics/window related, details including accepting + * and passing off incoming operating system raised events. + */ +class OperatingSystem +{ +public: + OperatingSystem() {} + virtual ~OperatingSystem() {} + + /** + * Initializes internal platform specific objects that wrap access + * to various operating system features so the game application class + * can make use of them. + * @return TRUE if successful, FALSE if not + */ + virtual BOOL Initialize() = 0; + + /** + * Creates a game window object for the given game application object. + * @param gameApp the game application object to create the window for + * @param params platform-specific window creation parameters + * @return TRUE if successful, FALSE if not + */ + virtual BOOL CreateGameWindow(BaseGameApp *gameApp, GameWindowParams *params) = 0; + + /** + * Checks for and handles any events raised by the operating system. + */ + virtual void ProcessEvents() = 0; + + /** + * Signals that the system should close as soon as possible, passing + * this signal up the chain to the window object. + */ + virtual void Quit() = 0; + + /** + * @return TRUE if the system has been signaled to quit + */ + virtual BOOL IsQuitting() const = 0; + + /** + * @return TRUE if hardware support for OpenGL shaders was detected + */ + virtual BOOL HasShaderSupport() const = 0; + + /** + * @return the version of shader support that the OpenGL hardware has + */ + virtual float GetSupportedShaderVersion() const = 0; + + /** + * @return the current game window object, or NULL if one does not exist yet + */ + virtual GameWindow* GetWindow() const = 0; + + /** + * @return file system object, or NULL if not available + */ + virtual FileSystem* GetFileSystem() const = 0; + + /** + * @return mouse input device object, or NULL if not available + */ + virtual Mouse* GetMouse() const = 0; + + /** + * @return keyboard input device object, or NULL if not available + */ + virtual Keyboard* GetKeyboard() const = 0; + + /** + * @return touchscreen input device object, or NULL if not available + */ + virtual Touchscreen* GetTouchscreen() const = 0; + + /** + * @return the number of milliseconds since program execution began + */ + virtual uint32_t GetTicks() const = 0; + + /** + * Blocks execution until the specified number of milliseconds has passed. + */ + virtual void Delay(uint32_t milliseconds) const = 0; +}; + +#endif diff --git a/src/framework/osevent.h b/src/framework/osevent.h new file mode 100644 index 0000000..d3d415f --- /dev/null +++ b/src/framework/osevent.h @@ -0,0 +1,12 @@ +#ifndef __FRAMEWORK_OSEVENT_H_INCLUDED__ +#define __FRAMEWORK_OSEVENT_H_INCLUDED__ + +/** + * Base struct for platform-specific event information. + */ +struct OSEvent +{ +}; + +#endif + diff --git a/src/framework/screenorientation.h b/src/framework/screenorientation.h new file mode 100644 index 0000000..4b5d79f --- /dev/null +++ b/src/framework/screenorientation.h @@ -0,0 +1,12 @@ +#ifndef __FRAMEWORK_SCREENORIENTATION_H_INCLUDED__ +#define __FRAMEWORK_SCREENORIENTATION_H_INCLUDED__ + +enum SCREEN_ORIENTATION_ANGLE +{ + SCREEN_ANGLE_0 = 0, + SCREEN_ANGLE_90 = 90, + SCREEN_ANGLE_180 = 180, + SCREEN_ANGLE_270 = 270 +}; + +#endif diff --git a/src/framework/sdlgamewindow.cpp b/src/framework/sdlgamewindow.cpp new file mode 100644 index 0000000..93c3a10 --- /dev/null +++ b/src/framework/sdlgamewindow.cpp @@ -0,0 +1,361 @@ +#ifdef SDL +#include "debug.h" +#include "log.h" + +#include "sdlgamewindow.h" + +#include "basegameapp.h" +#include "gamewindow.h" +#include "screenorientation.h" +#include "sdlsystemevent.h" +#include "sdlincludes.h" + +SDLGameWindow::SDLGameWindow(BaseGameApp *gameApp) + : GameWindow(gameApp) +{ + STACK_TRACE; + m_active = FALSE; + m_focused = FALSE; + m_closing = FALSE; + m_hasCurrentGLContext = FALSE; + m_screenOrientation = SCREEN_ANGLE_0; + m_SDLflags = 0; + m_originalWidth = 0; + m_originalHeight = 0; + m_width = 0; + m_height = 0; + m_rect.left = 0; + m_rect.top = 0; + m_rect.right = 0; + m_rect.bottom = 0; + m_bpp = 0; + m_fullscreen = FALSE; + m_screen = NULL; +} + +SDLGameWindow::~SDLGameWindow() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_WINDOW, "Releasing.\n"); +} + +BOOL SDLGameWindow::Create(GameWindowParams *params) +{ + STACK_TRACE; + LOG_INFO(LOGCAT_WINDOW, "Creating a window.\n"); + + SDLGameWindowParams *sdlParams = (SDLGameWindowParams*)params; + + LOG_INFO(LOGCAT_WINDOW, "Received window creation parameters:\n"); + LOG_INFO(LOGCAT_WINDOW, " title = \"%s\"\n", sdlParams->title.c_str()); + LOG_INFO(LOGCAT_WINDOW, " width = %d\n", sdlParams->width); + LOG_INFO(LOGCAT_WINDOW, " height = %d\n", sdlParams->height); + LOG_INFO(LOGCAT_WINDOW, " bpp = %d\n", sdlParams->bpp); + LOG_INFO(LOGCAT_WINDOW, " windowed = %d\n", sdlParams->windowed); + LOG_INFO(LOGCAT_WINDOW, " resizable = %d\n", sdlParams->resizable); + + uint32_t flags = SDL_OPENGL; + if (!sdlParams->windowed) + flags |= SDL_FULLSCREEN; + if (sdlParams->resizable) + flags |= SDL_RESIZABLE; + + m_SDLflags = flags; + m_bpp = sdlParams->bpp; + m_fullscreen = !sdlParams->windowed; + + // Trust that the initial video resolution specified will work, and save it as the fallback + m_originalWidth = sdlParams->width; + m_originalHeight = sdlParams->height; + + DisplaySdlHardwareInfo(); + + // Set the video mode + if (!SetUpWindow(sdlParams->width, sdlParams->height)) + return FALSE; + + SDL_WM_SetCaption(sdlParams->title.c_str(), sdlParams->title.c_str()); + LOG_INFO(LOGCAT_WINDOW, "Application window caption set: \"%s\"\n", sdlParams->title.c_str()); + + LOG_INFO(LOGCAT_WINDOW, "Finished initialization.\n"); + + LOG_INFO(LOGCAT_WINDOW, "Window marked active.\n"); + m_active = TRUE; + m_focused = TRUE; + + return TRUE; +} + +BOOL SDLGameWindow::Resize(uint16_t width, uint16_t height) +{ + STACK_TRACE; + BOOL result = SetUpWindow(width, height); + GetGameApp()->OnNewContext(); + GetGameApp()->OnResize(); + return result; +} + +BOOL SDLGameWindow::ToggleFullscreen() +{ + STACK_TRACE; + BOOL screenToggleResult; + if (m_fullscreen) + LOG_INFO(LOGCAT_WINDOW, "Beginning switch to windowed mode...\n"); + else + LOG_INFO(LOGCAT_WINDOW, "Beginning switch to fullscreen mode...\n"); + + GetGameApp()->OnLostContext(); + m_hasCurrentGLContext = FALSE; + + m_SDLflags ^= SDL_FULLSCREEN; + if (m_SDLflags & SDL_FULLSCREEN) + m_fullscreen = TRUE; + else + m_fullscreen = FALSE; + + screenToggleResult = Resize(m_width, m_height); + if (!screenToggleResult) + { + LOG_ERROR(LOGCAT_WINDOW, "Failed to toggle fullscreen/windowed mode (%dx%dx%d, fullscreen = %d).\n", m_width, m_height, m_bpp, m_fullscreen); + ASSERT(screenToggleResult == TRUE); + return FALSE; + } + + if (m_fullscreen) + LOG_INFO(LOGCAT_WINDOW, "Finished switch to fullscreen mode.\n"); + else + LOG_INFO(LOGCAT_WINDOW, "Finished switch to windowed mode.\n"); + + return TRUE; +} + +void SDLGameWindow::DisplaySdlHardwareInfo() +{ + STACK_TRACE; + const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo(); + char *videoDriver = new char[100]; + videoDriver = SDL_VideoDriverName(videoDriver, 100); + ASSERT(videoDriver != NULL); + + LOG_INFO(LOGCAT_WINDOW, "SDL renderer using the following video hardware/implementation:\n"); + LOG_INFO(LOGCAT_WINDOW, " Video driver: %s\n", videoDriver); + LOG_INFO(LOGCAT_WINDOW, " hw_available: %ld\n", videoInfo->hw_available); + LOG_INFO(LOGCAT_WINDOW, " wm_available: %ld\n", videoInfo->wm_available); + LOG_INFO(LOGCAT_WINDOW, " blit_hw: %ld\n", videoInfo->blit_hw); + LOG_INFO(LOGCAT_WINDOW, " blit_hw_CC: %ld\n", videoInfo->blit_hw_CC); + LOG_INFO(LOGCAT_WINDOW, " blit_hw_A: %ld\n", videoInfo->blit_hw_A); + LOG_INFO(LOGCAT_WINDOW, " blit_sw: %ld\n", videoInfo->blit_sw); + LOG_INFO(LOGCAT_WINDOW, " blit_sw_CC: %ld\n", videoInfo->blit_sw_CC); + LOG_INFO(LOGCAT_WINDOW, " blit_sw_A: %ld\n", videoInfo->blit_sw_A); + LOG_INFO(LOGCAT_WINDOW, " blit_fill: %ld\n", videoInfo->blit_fill); + LOG_INFO(LOGCAT_WINDOW, " video_mem: %ld\n", videoInfo->video_mem); + LOG_INFO(LOGCAT_WINDOW, " vfmt: %ld (best)\n", videoInfo->vfmt->BitsPerPixel); + LOG_INFO(LOGCAT_WINDOW, " current_w: %ld\n", videoInfo->current_w); + LOG_INFO(LOGCAT_WINDOW, " current_h: %ld\n", videoInfo->current_h); + + delete videoDriver; + + LOG_INFO(LOGCAT_WINDOW, "SDL Video Flags selected: SDL_OPENGL%s%s\n", (m_SDLflags & SDL_FULLSCREEN) ? ", SDL_FULLSCREEN" : "", (m_SDLflags & SDL_RESIZABLE) ? ", SDL_RESIZABLE" : ""); + + uint32_t tempFlags = m_SDLflags; + if (tempFlags & SDL_RESIZABLE) + tempFlags ^= SDL_RESIZABLE; + + SDL_Rect **windowedModes = SDL_ListModes(NULL, tempFlags); + SDL_Rect **fullscreenModes = SDL_ListModes(NULL, tempFlags | SDL_FULLSCREEN); + + ASSERT(windowedModes != NULL); + ASSERT(fullscreenModes != NULL); + + // Windowed display resolutions available + LOG_INFO(LOGCAT_WINDOW, "Supported windowed video modes with selected flags:\n"); + if (windowedModes == (SDL_Rect**)-1) + LOG_INFO(LOGCAT_WINDOW, " All video modes are available.\n"); + else + { + for (int i = 0; windowedModes[i]; i++) + LOG_INFO(LOGCAT_WINDOW, " %d. %d x %d\n", i + 1, windowedModes[i]->w, windowedModes[i]->h); + } + + // Fullscreen display resolutions available + LOG_INFO(LOGCAT_WINDOW, "Supported fullscreen video modes with selected flags:\n"); + if (fullscreenModes == (SDL_Rect**)-1) + LOG_INFO(LOGCAT_WINDOW, " All video modes are available.\n"); + else + { + for (int i = 0; fullscreenModes[i]; i++) + LOG_INFO(LOGCAT_WINDOW, " %d. %d x %d\n", i + 1, fullscreenModes[i]->w, fullscreenModes[i]->h); + } +} + +BOOL SDLGameWindow::SetUpWindow(uint16_t width, uint16_t height) +{ + STACK_TRACE; + int ret; + const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo(); + + LOG_INFO(LOGCAT_WINDOW, "Attempting to set up new window: %dx%d @ %d bpp, %s.\n", width, height, m_bpp, (m_SDLflags & SDL_FULLSCREEN ? "fullscreen" : "windowed")); + + // Check for requested video mode + ret = SDL_VideoModeOK(width, height, (m_bpp != 0 ? m_bpp : videoInfo->vfmt->BitsPerPixel), m_SDLflags); + if (!ret) + { + ret = SDL_VideoModeOK(m_originalWidth, m_originalHeight, (m_bpp != 0 ? m_bpp : videoInfo->vfmt->BitsPerPixel), m_SDLflags); + if (!ret) + { + LOG_WARN(LOGCAT_WINDOW, "Video mode %dx%d @ %d bpp not supported.\n", width, height, m_bpp); + return FALSE; + } + + width = m_originalWidth; + height = m_originalHeight; + LOG_WARN(LOGCAT_WINDOW, "Fall back to application's original display resolution %dx%d.\n", m_originalWidth, m_originalHeight); + } + + LOG_INFO(LOGCAT_WINDOW, "SDL_VideoModeOK() returned a BPP of %d.\n", ret); + + // Request minimum settings + SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); + SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); + SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + + if ((m_screen = SDL_SetVideoMode(width, height, m_bpp, m_SDLflags)) == NULL) + { + LOG_ERROR(LOGCAT_WINDOW, "Could not set video mode %dx%dx%d (flags = %ld): %s\n", width, height, m_bpp, m_SDLflags, SDL_GetError()); + return FALSE; + } + LOG_INFO(LOGCAT_WINDOW, "Video mode %dx%d @ %d bpp set.\n", width, height, m_bpp); + + int value = 0; + SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); + LOG_INFO(LOGCAT_WINDOW, "SDL_GL_RED_SIZE: %d\n", value); + SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); + LOG_INFO(LOGCAT_WINDOW, "SDL_GL_GREEN_SIZE: %d\n", value); + SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); + LOG_INFO(LOGCAT_WINDOW, "SDL_GL_BLUE_SIZE: %d\n", value); + SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); + LOG_INFO(LOGCAT_WINDOW, "SDL_GL_DEPTH_SIZE: %d\n", value); + SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &value); + LOG_INFO(LOGCAT_WINDOW, "SDL_GL_DOUBLEBUFFER: %d\n", value); + + if (GetScreenOrientation() == SCREEN_ANGLE_90 || GetScreenOrientation() == SCREEN_ANGLE_270) + { + m_width = height; + m_height = width; + m_rect.left = 0; + m_rect.top = 0; + m_rect.right = m_rect.top + height; + m_rect.bottom = m_rect.left + width; + } + else + { + m_width = width; + m_height = height; + m_rect.left = 0; + m_rect.top = 0; + m_rect.right = m_rect.left + width; + m_rect.bottom = m_rect.top + height; + } + + m_hasCurrentGLContext = TRUE; + + return TRUE; +} + +void SDLGameWindow::ProcessEvent(const OSEvent *event) +{ + STACK_TRACE; + if (IsClosing()) + return; + + const SDLSystemEvent *evt = (SDLSystemEvent*)event; + BOOL resizeResult; + + switch (evt->event->type) + { + case SDL_ACTIVEEVENT: + LOG_INFO(LOGCAT_WINDOW, "Event: SDL_ACTIVEEVENT\n"); + if (evt->event->active.state & SDL_APPACTIVE) + { + // Disable rendering if the application was minimized + if (evt->event->active.gain) + { + LOG_INFO(LOGCAT_WINDOW, "Window focus gained.\n"); + LOG_INFO(LOGCAT_WINDOW, "Window marked active.\n"); + m_active = TRUE; + + // ensure we render again now that rendering has been resumed + // (the window might have been minimized or covered up) + GetGameApp()->Invalidate(); + } + else + { + LOG_INFO(LOGCAT_WINDOW, "Window focus lost.\n"); + LOG_INFO(LOGCAT_WINDOW, "Window marked inactive.\n"); + m_active = FALSE; + } + } + if (evt->event->active.state & SDL_APPMOUSEFOCUS) + { + if (evt->event->active.gain) + LOG_INFO(LOGCAT_WINDOW, "Gained mouse focus.\n"); + else + LOG_INFO(LOGCAT_WINDOW, "Lost mouse focus.\n"); + } + if (evt->event->active.state & SDL_APPINPUTFOCUS) + { + if (evt->event->active.gain) + { + LOG_INFO(LOGCAT_WINDOW, "Gained input device focus.\n"); + m_focused = TRUE; + GetGameApp()->OnAppGainFocus(); + } + else + { + LOG_INFO(LOGCAT_WINDOW, "Lost input device focus.\n"); + m_focused = FALSE; + GetGameApp()->OnAppLostFocus(); + } + } + break; + + case SDL_VIDEORESIZE: + LOG_INFO(LOGCAT_WINDOW, "Event: SDL_VIDEORESIZE\n"); + // Window resizing involves resetting the SDL video mode, which therefore also requires + // re-initializing OpenGL + LOG_INFO(LOGCAT_WINDOW, "Window resized to %dx%d.\n", evt->event->resize.w, evt->event->resize.h); + GetGameApp()->OnLostContext(); + m_hasCurrentGLContext = FALSE; + resizeResult = SetUpWindow(evt->event->resize.w, evt->event->resize.h); + GetGameApp()->OnNewContext(); + GetGameApp()->OnResize(); + if (!resizeResult) + { + LOG_ERROR(LOGCAT_WINDOW, "Window resize to %dx%d failed!\n", evt->event->resize.w, evt->event->resize.h); + ASSERT(resizeResult == TRUE); + Close(); + return; + } + break; + } +} + +void SDLGameWindow::Close() +{ + STACK_TRACE; + if (m_active) + { + LOG_INFO(LOGCAT_WINDOW, "Window marked inactive.\n"); + m_active = FALSE; + m_focused = FALSE; + } + else + LOG_INFO(LOGCAT_WINDOW, "Window was already marked inactive.\n"); + + LOG_INFO(LOGCAT_WINDOW, "Closing.\n"); + m_closing = TRUE; +} +#endif + diff --git a/src/framework/sdlgamewindow.h b/src/framework/sdlgamewindow.h new file mode 100644 index 0000000..c25bf2b --- /dev/null +++ b/src/framework/sdlgamewindow.h @@ -0,0 +1,72 @@ +#ifdef SDL +#ifndef __FRAMEWORK_SDLGAMEWINDOW_H_INCLUDED__ +#define __FRAMEWORK_SDLGAMEWINDOW_H_INCLUDED__ + +#include "common.h" +#include "gamewindow.h" +#include "screenorientation.h" +#include "sdlincludes.h" +#include + +#include "math/rect.h" + +class BaseGameApp; + +struct SDLGameWindowParams : GameWindowParams +{ + stl::string title; + uint16_t width; + uint16_t height; + uint8_t bpp; + BOOL resizable; +}; + +class SDLGameWindow : public GameWindow +{ +public: + SDLGameWindow(BaseGameApp *gameApp); + virtual ~SDLGameWindow(); + + BOOL Create(GameWindowParams *params); + BOOL Resize(uint16_t width, uint16_t height); + BOOL ToggleFullscreen(); + void Close(); + + uint16_t GetWidth() const { return m_width; } + uint16_t GetHeight() const { return m_height; } + const Rect& GetRect() const { return m_rect; } + uint8_t GetBPP() const { return m_bpp; } + BOOL IsWindowed() const { return m_fullscreen; } + SCREEN_ORIENTATION_ANGLE GetScreenOrientation() const { return m_screenOrientation; } + + BOOL IsActive() const { return m_active; } + BOOL IsFocused() const { return m_focused; } + BOOL IsClosing() const { return m_closing; } + BOOL HasGLContext() const { return m_hasCurrentGLContext; } + + void ProcessEvent(const OSEvent *event); + void Flip() { SDL_GL_SwapBuffers(); } + +private: + void DisplaySdlHardwareInfo(); + BOOL SetUpWindow(uint16_t width, uint16_t height); + + BOOL m_active; + BOOL m_focused; + BOOL m_closing; + BOOL m_hasCurrentGLContext; + + SCREEN_ORIENTATION_ANGLE m_screenOrientation; + uint32_t m_SDLflags; + uint16_t m_originalWidth; + uint16_t m_originalHeight; + uint16_t m_width; + uint16_t m_height; + Rect m_rect; + uint8_t m_bpp; + BOOL m_fullscreen; + SDL_Surface *m_screen; +}; + +#endif +#endif diff --git a/src/framework/sdlincludes.h b/src/framework/sdlincludes.h new file mode 100644 index 0000000..524afdc --- /dev/null +++ b/src/framework/sdlincludes.h @@ -0,0 +1,14 @@ +#ifdef SDL +#ifndef __FRAMEWORK_SDLINCLUDES_H_INCLUDED__ +#define __FRAMEWORK_SDLINCLUDES_H_INCLUDED__ + +// this solely exists because MSVC is usually the only compiler where I *may* have +// SDL headers in a non-standard spot +#ifdef _MSC_VER +#include +#else +#include +#endif + +#endif +#endif \ No newline at end of file diff --git a/src/framework/sdlsystem.cpp b/src/framework/sdlsystem.cpp new file mode 100644 index 0000000..431481a --- /dev/null +++ b/src/framework/sdlsystem.cpp @@ -0,0 +1,277 @@ +#ifdef SDL +#include "debug.h" +#include "log.h" + +#include "sdlsystem.h" + +#include "basegameapp.h" +#include "gamewindow.h" +#include "osevent.h" +#include "sdlgamewindow.h" +#include "sdlsystemevent.h" +#include "file/filesystem.h" +#include "file/sdlfilesystem.h" +#include "graphics/glincludes.h" +#include "input/mouse.h" +#include "input/keyboard.h" +#include "input/sdlmouse.h" +#include "input/sdlkeyboard.h" +#include "sdlincludes.h" + +SDLSystem::SDLSystem() + : OperatingSystem() +{ + STACK_TRACE; + m_isQuitting = FALSE; + m_hasShaderSupport = FALSE; + m_window = NULL; + m_filesystem = NULL; + m_mouse = NULL; + m_keyboard = NULL; +} + +SDLSystem::~SDLSystem() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "Releasing.\n"); + + if (!m_isQuitting) + { + LOG_WARN(LOGCAT_SYSTEM, "Was not signaled to quit. Calling Quit() now."); + Quit(); + } + + SAFE_DELETE(m_window); + + SAFE_DELETE(m_filesystem); + SAFE_DELETE(m_mouse); + SAFE_DELETE(m_keyboard); + + LOG_INFO(LOGCAT_SYSTEM, "Shutting down SDL.\n"); + SDL_Quit(); +} + +BOOL SDLSystem::Initialize() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "SDLSystem initialization starting.\n"); + + const SDL_version *SDLversion = SDL_Linked_Version(); + LOG_INFO(LOGCAT_SYSTEM, "SDL Runtime Version: %u.%u.%u, Linked Version: %u.%u.%u\n", SDLversion->major, SDLversion->minor, SDLversion->patch, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL); + + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_TIMER) == -1) + { + LOG_ERROR(LOGCAT_SYSTEM, "SDL_Init() failed: %s\n", SDL_GetError()); + return FALSE; + } + LOG_INFO(LOGCAT_SYSTEM, "SDL_Init() passed.\n"); + + m_mouse = new SDLMouse(this); + ASSERT(m_mouse != NULL); + LOG_INFO(LOGCAT_SYSTEM, "Mouse input device available.\n"); + + m_keyboard = new SDLKeyboard(this, TRUE); + ASSERT(m_keyboard != NULL); + LOG_INFO(LOGCAT_SYSTEM, "Keyboard input device available.\n"); + + int numJoysticks = SDL_NumJoysticks(); + SDL_Joystick *joystick; + + LOG_INFO(LOGCAT_SYSTEM, "%d joystick input devices found\n", numJoysticks); + + for (int i = 0; i < numJoysticks; i++) + { + LOG_INFO(LOGCAT_SYSTEM, "Joystick #%d. %s:\n", (i + 1), SDL_JoystickName(i)); + + joystick = SDL_JoystickOpen(i); + if (joystick) + { + LOG_INFO(LOGCAT_SYSTEM, "\tAxes: %d\n", SDL_JoystickNumAxes(joystick)); + LOG_INFO(LOGCAT_SYSTEM, "\tBalls: %d\n", SDL_JoystickNumBalls(joystick)); + LOG_INFO(LOGCAT_SYSTEM, "\tHats: %d\n", SDL_JoystickNumHats(joystick)); + LOG_INFO(LOGCAT_SYSTEM, "\tButtons: %d\n", SDL_JoystickNumButtons(joystick)); + + SDL_JoystickClose(joystick); + } + else + LOG_WARN(LOGCAT_SYSTEM, "\tMore information could not be obtained.\n"); + } + + LOG_INFO(LOGCAT_SYSTEM, "Initializing file system access.\n"); + m_filesystem = new SDLFileSystem(); + ASSERT(m_filesystem != NULL); + + LOG_INFO(LOGCAT_SYSTEM, "Finished SDLSystem initialization.\n"); + + return TRUE; +} + +BOOL SDLSystem::CreateGameWindow(BaseGameApp *gameApp, GameWindowParams *params) +{ + STACK_TRACE; + ASSERT(m_window == NULL); + + SDLGameWindow *window = new SDLGameWindow(gameApp); + ASSERT(window != NULL); + + if (!window->Create(params)) + { + LOG_ERROR(LOGCAT_SYSTEM, "Failed to create a GameWindow.\n"); + return FALSE; + } + + m_window = window; + + // now that we have a window (and a GL context), set up OpenGL related stuff + + GLenum err = glewInit(); + if (GLEW_OK != err) + { + LOG_ERROR(LOGCAT_SYSTEM, "GLEW failed to initialize: %s\n", glewGetErrorString(err)); + return FALSE; + } + LOG_INFO(LOGCAT_SYSTEM, "GLEW %s initialized. OpenGL extensions loaded.\n", glewGetString(GLEW_VERSION)); + + // Determine if shaders are supported by the video card + if (GLEW_ARB_vertex_shader || GLEW_ARB_vertex_program) + { + m_hasShaderSupport = TRUE; + + // Since shaders are supported, try to determine what the exact shader version that + // is supported is by the presence of the different extensions + // (Ref: http://ogltotd.blogspot.com/2006/12/checking-for-d3d-shader-version.html ) + m_supportedShaderVersion = 1.1f; + if (GLEW_NV_texture_shader && GLEW_NV_register_combiners) + m_supportedShaderVersion = 1.1f; + if (GLEW_ATI_fragment_shader || GLEW_ATI_text_fragment_shader) + m_supportedShaderVersion = 1.4f; + if (GLEW_ARB_fragment_program || GLEW_ARB_fragment_shader) + m_supportedShaderVersion = 2.0f; + if (GLEW_NV_vertex_program3) + m_supportedShaderVersion = 3.0f; + if (GLEW_NV_gpu_program4 || GLEW_EXT_gpu_shader4) + m_supportedShaderVersion = 4.0f; + } + else + m_hasShaderSupport = FALSE; + + // display opengl hardware/support information + // TODO: probably should just look at the GL_VERSION string since that's + // what GLEW is actually doing under the hood... + if (GLEW_VERSION_4_2) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 4.2 support present.\n"); + else if (GLEW_VERSION_4_1) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 4.1 support present.\n"); + else if (GLEW_VERSION_4_0) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 4.0 support present.\n"); + else if (GLEW_VERSION_3_3) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 3.3 support present.\n"); + else if (GLEW_VERSION_3_2) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 3.2 support present.\n"); + else if (GLEW_VERSION_3_1) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 3.1 support present.\n"); + else if (GLEW_VERSION_3_0) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 3.0 support present.\n"); + else if (GLEW_VERSION_2_1) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 2.1 support present.\n"); + else if (GLEW_VERSION_2_0) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 2.0 support present.\n"); + else if (GLEW_VERSION_1_5) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 1.5 support present.\n"); + else if (GLEW_VERSION_1_4) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 1.4 support present.\n"); + else if (GLEW_VERSION_1_3) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 1.3 support present.\n"); + else if (GLEW_VERSION_1_2) + LOG_INFO(LOGCAT_SYSTEM, "OpenGL 1.2 support present.\n"); + else + LOG_WARN(LOGCAT_SYSTEM, "Unknown version of OpenGL.\n"); + + LOG_INFO(LOGCAT_SYSTEM, "OpenGL renderer using the following video hardware:\n"); + LOG_INFO(LOGCAT_SYSTEM, "GL_VENDOR: %s\n", glGetString(GL_VENDOR)); + LOG_INFO(LOGCAT_SYSTEM, "GL_RENDERER: %s\n", glGetString(GL_RENDERER)); + LOG_INFO(LOGCAT_SYSTEM, "GL_VERSION: %s\n", glGetString(GL_VERSION)); + LOG_INFO(LOGCAT_SYSTEM, "GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS)); + + if (m_hasShaderSupport) + { + LOG_INFO(LOGCAT_SYSTEM, "Video card supports Shader Model %.1f.\n", m_supportedShaderVersion); + LOG_INFO(LOGCAT_SYSTEM, "GL_SHADING_LANGUAGE_VERSION: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); + } + else + LOG_INFO(LOGCAT_SYSTEM, "Video card does not support shaders.\n"); + + LOG_INFO(LOGCAT_SYSTEM, "GameWindow instance is ready.\n"); + + return TRUE; +} + +void SDLSystem::ProcessEvents() +{ + STACK_TRACE; + + // little bit of housekeeping + m_mouse->ResetDeltas(); + + SDL_Event event; + SDLSystemEvent evt; + + while (SDL_PollEvent(&event)) + { + switch (event.type) + { + case SDL_ACTIVEEVENT: + LOG_INFO(LOGCAT_SYSTEM, "Event: SDL_ACTIVEEVENT. Passing to GameWindow.\n"); + evt.event = &event; + m_window->ProcessEvent(&evt); + break; + + case SDL_VIDEORESIZE: + LOG_INFO(LOGCAT_SYSTEM, "Event: SDL_VIDEORESIZE. Passing to GameWindow.\n"); + evt.event = &event; + m_window->ProcessEvent(&evt); + break; + + case SDL_QUIT: + LOG_INFO(LOGCAT_SYSTEM, "Event: SDL_QUIT\n"); + Quit(); + break; + + case SDL_KEYDOWN: + m_keyboard->OnKeyEvent(&event.key); + break; + + case SDL_KEYUP: + m_keyboard->OnKeyEvent(&event.key); + break; + + case SDL_MOUSEMOTION: + m_mouse->OnMotionEvent(&event.motion); + break; + + case SDL_MOUSEBUTTONDOWN: + m_mouse->OnButtonEvent(&event.button); + break; + + case SDL_MOUSEBUTTONUP: + m_mouse->OnButtonEvent(&event.button); + break; + } + } +} + +void SDLSystem::Quit() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_SYSTEM, "Quit requested.\n"); + m_isQuitting = TRUE; + + if (m_window != NULL && !m_window->IsClosing()) + { + LOG_INFO(LOGCAT_SYSTEM, "Signaling window to close.\n"); + m_window->Close(); + } + +} +#endif + diff --git a/src/framework/sdlsystem.h b/src/framework/sdlsystem.h new file mode 100644 index 0000000..6a4c85c --- /dev/null +++ b/src/framework/sdlsystem.h @@ -0,0 +1,63 @@ +#ifdef SDL +#ifndef __FRAMEWORK_SDLSYSTEM_H_INCLUDED__ +#define __FRAMEWORK_SDLSYSTEM_H_INCLUDED__ + +#include "common.h" +#include "sdlincludes.h" + +#include "operatingsystem.h" +#include "sdlgamewindow.h" +#include "file/sdlfilesystem.h" + +class BaseGameApp; +class FileSystem; +class GameWindow; +class Mouse; +class Keyboard; +class Touchscreen; +class SDLFileSystem; +class SDLGameWindow; +class SDLMouse; +class SDLKeyboard; +struct GameWindowParams; + +class SDLSystem : public OperatingSystem +{ +public: + SDLSystem(); + virtual ~SDLSystem(); + + BOOL Initialize(); + BOOL CreateGameWindow(BaseGameApp *gameApp, GameWindowParams *params); + void ProcessEvents(); + void Quit(); + + BOOL IsQuitting() const { return m_isQuitting; } + + BOOL HasShaderSupport() const { return m_hasShaderSupport; } + float GetSupportedShaderVersion() const { return m_supportedShaderVersion; } + + GameWindow* GetWindow() const { return m_window; } + FileSystem* GetFileSystem() const { return m_filesystem; } + Mouse* GetMouse() const { return (Mouse*)m_mouse; } + Keyboard* GetKeyboard() const { return (Keyboard*)m_keyboard; } + Touchscreen* GetTouchscreen() const { return NULL; } + + uint32_t GetTicks() const { return SDL_GetTicks(); } + void Delay(uint32_t milliseconds) const { return SDL_Delay(milliseconds); } + +private: + BOOL m_isQuitting; + + SDLGameWindow *m_window; + SDLFileSystem *m_filesystem; + SDLMouse *m_mouse; + SDLKeyboard *m_keyboard; + + BOOL m_hasShaderSupport; + float m_supportedShaderVersion; +}; + +#endif +#endif + diff --git a/src/framework/sdlsystemevent.h b/src/framework/sdlsystemevent.h new file mode 100644 index 0000000..53e6095 --- /dev/null +++ b/src/framework/sdlsystemevent.h @@ -0,0 +1,14 @@ +#ifdef SDL +#ifndef __FRAMEWORK_SDLSYSTEMEVENT_H_INCLUDED__ +#define __FRAMEWORK_SDLSYSTEMEVENT_H_INCLUDED__ + +#include "osevent.h" +#include "sdlincludes.h" + +struct SDLSystemEvent : OSEvent +{ + SDL_Event *event; +}; + +#endif +#endif diff --git a/src/framework/support/animationsequence.h b/src/framework/support/animationsequence.h new file mode 100644 index 0000000..10f060b --- /dev/null +++ b/src/framework/support/animationsequence.h @@ -0,0 +1,42 @@ +#ifndef __FRAMEWORK_SUPPORT_ANIMATIONSEQUENCE_H_INCLUDED__ +#define __FRAMEWORK_SUPPORT_ANIMATIONSEQUENCE_H_INCLUDED__ + +#include "../common.h" +#include +#include + +struct AnimationSequence +{ + uint32_t start; + uint32_t stop; + float delay; + BOOL tileIsMultiDirectional; + uint32_t tileDirectionFrameOffset; + + AnimationSequence(); + AnimationSequence(uint32_t start, uint32_t stop, float delay = 1.0f, BOOL tileIsMultiDirectional = FALSE, uint32_t tileDirectionFrameOffset = 0); +}; + +typedef stl::map AnimationList; +typedef stl::map AnimationListPtr; + +inline AnimationSequence::AnimationSequence() +{ + this->start = 0; + this->stop = 0; + this->delay = 0.0f; + this->tileIsMultiDirectional = FALSE; + this->tileDirectionFrameOffset = 0; +} + +inline AnimationSequence::AnimationSequence(uint32_t start, uint32_t stop, float delay, BOOL tileIsMultiDirectional, uint32_t tileDirectionFrameOffset) +{ + this->start = start; + this->stop = stop; + this->delay = delay; + this->tileIsMultiDirectional = tileIsMultiDirectional; + this->tileDirectionFrameOffset = tileDirectionFrameOffset; +} + +#endif + diff --git a/src/framework/support/freecamera.cpp b/src/framework/support/freecamera.cpp new file mode 100644 index 0000000..5c4fdd0 --- /dev/null +++ b/src/framework/support/freecamera.cpp @@ -0,0 +1,80 @@ +#include "../debug.h" + +#include "freecamera.h" + +#include "../basegameapp.h" +#include "../input/keyboard.h" +#include "../input/mouse.h" +#include "../input/touchscreen.h" +#include "../math/mathhelpers.h" +#include "../math/vector3.h" + +FreeCamera::FreeCamera(ViewContext *viewContext, BaseGameApp *gameApp) + : Camera(viewContext) +{ + STACK_TRACE; + m_gameApp = gameApp; + m_movement = ZERO_VECTOR; + m_forward = ZERO_VECTOR; +} + +FreeCamera::~FreeCamera() +{ + STACK_TRACE; +} + +void FreeCamera::Move(float x, float y, float z) +{ + STACK_TRACE; + GetPosition().x += x; + GetPosition().y += y; + GetPosition().z += z; +} + +void FreeCamera::Orient(float x, float y, float z) +{ + STACK_TRACE; + GetOrientation().x += x; + GetOrientation().y += y; + GetOrientation().z += z; +} + +void FreeCamera::OnUpdate(float delta) +{ + STACK_TRACE; +#ifdef MOBILE + if (m_gameApp->GetTouchscreen()->IsTouching()) + { + const TouchPointer *p = m_gameApp->GetTouchscreen()->GetPrimaryPointer(); + GetOrientation().y += p->GetDeltaX() * 0.01f; + GetOrientation().x += p->GetDeltaY() * 0.01f; + + GetOrientation().y = RolloverClamp(GetOrientation().y, RADIANS_0, RADIANS_360); + GetOrientation().x = RolloverClamp(GetOrientation().x, RADIANS_0, RADIANS_360); + } + + m_movement = ZERO_VECTOR; +#else + if (m_gameApp->GetMouse()->IsDown(MOUSE_LEFT)) + { + GetOrientation().y += m_gameApp->GetMouse()->GetDeltaX() * 0.01f; + GetOrientation().x += m_gameApp->GetMouse()->GetDeltaY() * 0.01f; + + GetOrientation().y = RolloverClamp(GetOrientation().y, RADIANS_0, RADIANS_360); + GetOrientation().x = RolloverClamp(GetOrientation().x, RADIANS_0, RADIANS_360); + } + + m_movement = ZERO_VECTOR; + + if (m_gameApp->GetKeyboard()->IsDown(KSYM_W)) + m_movement.z -= delta * 6.0f; + if (m_gameApp->GetKeyboard()->IsDown(KSYM_S)) + m_movement.z += delta * 6.0f; + if (m_gameApp->GetKeyboard()->IsDown(KSYM_A)) + m_movement.x -= delta * 6.0f; + if (m_gameApp->GetKeyboard()->IsDown(KSYM_D)) + m_movement.x += delta * 6.0f; +#endif + + UpdateLookAtMatrix(m_movement); +} diff --git a/src/framework/support/freecamera.h b/src/framework/support/freecamera.h new file mode 100644 index 0000000..8954ff9 --- /dev/null +++ b/src/framework/support/freecamera.h @@ -0,0 +1,27 @@ +#ifndef __FRAMEWORK_SUPPORT_FREECAMERA_H_INCLUDED__ +#define __FRAMEWORK_SUPPORT_FREECAMERA_H_INCLUDED__ + +#include "../math/camera.h" + +class BaseGameApp; +class ViewContext; +struct Vector3; + +class FreeCamera : public Camera +{ +public: + FreeCamera(ViewContext *viewContext, BaseGameApp *gameApp); + virtual ~FreeCamera(); + + void Move(float x, float y, float z); + void Orient(float x, float y, float z); + void OnUpdate(float delta); + +private: + BaseGameApp *m_gameApp; + Vector3 m_movement; + Vector3 m_forward; + +}; + +#endif diff --git a/src/framework/support/grid.cpp b/src/framework/support/grid.cpp new file mode 100644 index 0000000..780dc1a --- /dev/null +++ b/src/framework/support/grid.cpp @@ -0,0 +1,95 @@ +#include "../debug.h" + +#include "grid.h" + +#include "../graphics/graphicsdevice.h" +#include "../graphics/renderstate.h" +#include "../graphics/vertexbuffer.h" + +Grid::Grid(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height) +{ + STACK_TRACE; + m_graphicsDevice = graphicsDevice; + + m_renderState = new RENDERSTATE_DEFAULT; + ASSERT(m_renderState != NULL); + + m_horizontalPoints = new VertexBuffer(BUFFEROBJECT_USAGE_STATIC); + ASSERT(m_horizontalPoints != NULL); + m_horizontalPoints->AddAttribute(VERTEX_POS_3D); + m_horizontalPoints->AddAttribute(VERTEX_COLOR); + m_horizontalPoints->AddAttribute(ATTRIB_SIZE_1F); + m_horizontalPoints->AddAttribute(ATTRIB_SIZE_1F); + m_horizontalPoints->Create(width * 2 + 2); + + m_verticalPoints = new VertexBuffer(BUFFEROBJECT_USAGE_STATIC); + ASSERT(m_verticalPoints != NULL); + m_verticalPoints->AddAttribute(VERTEX_POS_3D); + m_verticalPoints->AddAttribute(VERTEX_COLOR); + m_verticalPoints->AddAttribute(ATTRIB_SIZE_1F); + m_verticalPoints->AddAttribute(ATTRIB_SIZE_1F); + m_verticalPoints->Create(height * 2 + 2); + + for (uint16_t i = 0; i < height + 1; ++i) + { + m_horizontalPoints->SetPosition3((i * 2), -(width / 2.0f), 0.0f, i - (height / 2.0f)); + m_horizontalPoints->SetColor((i * 2), 1.0f, 1.0f, 1.0f); + m_horizontalPoints->SetPosition3((i * 2) + 1, width / 2.0f, 0.0f, i - (height / 2.0f)); + m_horizontalPoints->SetColor((i * 2) + 1, 1.0f, 1.0f, 1.0f); + + if (i == 8) + { + m_horizontalPoints->Set1f(3, (i * 2), 1.0f); + m_horizontalPoints->Set1f(3, (i * 2) + 1, 1.0f); + } + else + { + m_horizontalPoints->Set1f(3, (i * 2), 0.0f); + m_horizontalPoints->Set1f(3, (i * 2) + 1, 0.0f); + } + m_horizontalPoints->Set1f(2, (i * 2), 2.0f); + m_horizontalPoints->Set1f(2, (i * 2) + 1, 3.0f); + } + + for (uint16_t i = 0; i < width + 1; ++i) + { + m_verticalPoints->SetPosition3((i * 2), i - (width / 2.0f), 0.0f, -(height / 2.0f)); + m_verticalPoints->SetColor((i * 2), 1.0f, 1.0f, 1.0f); + m_verticalPoints->SetPosition3((i * 2) + 1, i - (width / 2.0f), 0.0f, height / 2.0f); + m_verticalPoints->SetColor((i * 2) + 1, 1.0f, 1.0f, 1.0f); + + if (i == 1) + { + m_verticalPoints->Set1f(3, (i * 2), 1.0f); + m_verticalPoints->Set1f(3, (i * 2) + 1, 1.0f); + } + else + { + m_verticalPoints->Set1f(3, (i * 2), 0.0f); + m_verticalPoints->Set1f(3, (i * 2) + 1, 0.0f); + } + m_verticalPoints->Set1f(2, (i * 2), 0.0f); + m_verticalPoints->Set1f(2, (i * 2) + 1, 0.0f); + } +} + +Grid::~Grid() +{ + STACK_TRACE; + SAFE_DELETE(m_horizontalPoints); + SAFE_DELETE(m_verticalPoints); +} + +void Grid::OnRender() +{ + STACK_TRACE; + m_renderState->Apply(); + + m_graphicsDevice->BindVertexBuffer(m_horizontalPoints); + m_graphicsDevice->RenderLines(0, m_horizontalPoints->GetNumElements() / 2); + m_graphicsDevice->UnbindVertexBuffer(); + + m_graphicsDevice->BindVertexBuffer(m_verticalPoints); + m_graphicsDevice->RenderLines(0, m_verticalPoints->GetNumElements() / 2); + m_graphicsDevice->UnbindVertexBuffer(); +} diff --git a/src/framework/support/grid.h b/src/framework/support/grid.h new file mode 100644 index 0000000..319064e --- /dev/null +++ b/src/framework/support/grid.h @@ -0,0 +1,25 @@ +#ifndef __FRAMEWORK_SUPPORT_GRID_H_INCLUDED__ +#define __FRAMEWORK_SUPPORT_GRID_H_INCLUDED__ + +#include "../common.h" + +class GraphicsDevice; +class RenderState; +class VertexBuffer; + +class Grid +{ +public: + Grid(GraphicsDevice *graphicsDevice, uint16_t width, uint16_t height); + virtual ~Grid(); + + void OnRender(); + +private: + GraphicsDevice *m_graphicsDevice; + VertexBuffer *m_horizontalPoints; + VertexBuffer *m_verticalPoints; + RenderState *m_renderState; +}; + +#endif diff --git a/src/framework/support/text.cpp b/src/framework/support/text.cpp new file mode 100644 index 0000000..2c66d08 --- /dev/null +++ b/src/framework/support/text.cpp @@ -0,0 +1,128 @@ +#include "../debug.h" + +#include "text.h" +#include "../file/file.h" +#include + +Text* Text::CreateFrom(File *file) +{ + STACK_TRACE; + ASSERT(file != NULL); + ASSERT(file->IsOpen()); + + size_t length = file->GetFileSize(); + + // we add 1 to the length so that we can ensure a NULL terminator is at the end + size_t allocSize = length + 1; + + int8_t *buffer = new int8_t[allocSize]; + + size_t bytesRead = file->Read(buffer, length); + ASSERT(bytesRead == length); + + // put a NULL terminator at the end first + buffer[allocSize - 1] = '\0'; + + Text *result = new Text((char*)buffer, allocSize); + ASSERT(result != NULL); + + return result; +} + +Text* Text::CreateFrom(const char *text, size_t length) +{ + STACK_TRACE; + ASSERT(text != NULL); + ASSERT(length > 0); + + size_t allocSize = length; + // if the source string does not have a NULL terminator at the end, we should add one + if (text[allocSize - 1] != '\0') + ++allocSize; + + char *ownText = new char[allocSize]; + memcpy(ownText, text, length); + + if (allocSize > length) + ownText[allocSize - 1] = '\0'; + + Text *result = new Text(ownText, allocSize); + ASSERT(result != NULL); + + return result; +} + +Text::Text(char *text, size_t length) +{ + STACK_TRACE; + ASSERT(text != NULL); + ASSERT(length > 0); + m_text = text; + m_length = length; + m_numLines = CountLines(); +} + +Text::~Text() +{ + STACK_TRACE; + SAFE_DELETE(m_text); +} + +uint32_t Text::CountLines() +{ + STACK_TRACE; + uint32_t numLines = 1; + for (uint32_t i = 0; i < m_length; ++i) + { + char c = m_text[i]; + if (c == '\n') + ++numLines; + } + + return numLines; +} + +const char* Text::GetLine(uint32_t line, size_t &lineLength) const +{ + STACK_TRACE; + ASSERT(line < m_numLines); + + // find the start of the requested line + uint32_t currentLine = 1; + const char* startOfLine = &m_text[0]; + + uint32_t i = 0; + while (line != currentLine && i < m_length) + { + char c = m_text[i]; + ++i; + + if (c == '\n') + { + // only track the start of new lines... + ++currentLine; + startOfLine = &m_text[i]; + } + } + + // now count up the characters to the end of this line + lineLength = 0; + while (i < m_length) + { + char c = m_text[i]; + ++i; + + if (c == '\n') + break; // end of line, don't count newline character in length + + ++lineLength; + } + + // on windows, newlines are "\r\n". we don't include '\n', so we shouldn't + // include '\r' either. right now, if on windows, '\r' will be at the end + // of the line if we just broke out of the previous loop upon finding a '\n' + if (*(startOfLine + (lineLength - 1)) == '\r') + --lineLength; + + return startOfLine; +} \ No newline at end of file diff --git a/src/framework/support/text.h b/src/framework/support/text.h new file mode 100644 index 0000000..b867732 --- /dev/null +++ b/src/framework/support/text.h @@ -0,0 +1,73 @@ +#ifndef __FRAMEWORK_SUPPORT_TEXT_H_INCLUDED__ +#define __FRAMEWORK_SUPPORT_TEXT_H_INCLUDED__ + +#include "../common.h" +#include "../content/content.h" + +class File; + +/** + * Represents one or more lines of text. + */ +class Text : public Content +{ +public: + static CONTENT_TYPE GetType() + { + static CONTENT_TYPE typeName = "Text"; + return typeName; + } + CONTENT_TYPE GetTypeOf() const { return GetType(); } + + /** + * Creates a text object from a text file. + * @param file the file to load as text + * @return a text object or NULL on failure + */ + static Text* CreateFrom(File *file); + + /** + * Creates a text object from an arbitrary string of text. + * @param text the source text to copy into this text object + * @param length the number of characters in the source text + * @return a text object or NULL on failure + */ + static Text* CreateFrom(const char *text, size_t length); + + virtual ~Text(); + + /** + * @return the text contained in this object + */ + const char* GetText() const { return m_text; } + + /** + * Gets a string for the specified line of text from this object. + * @param line the line to get a string for (line 1 is the first line) + * @param lineLength will contain the number of characters in the + * retrieved line, not including new-line characters + * @return pointer to the text starting at the specified line + */ + const char* GetLine(uint32_t line, size_t &lineLength) const; + + /** + * @return the total number of characters in this text object + */ + size_t GetLength() const { return m_length; } + + /** + * @return the number of lines of text in this text object + */ + uint32_t GetNumLines() const { return m_numLines; } + +private: + Text(char *text, size_t length); + + uint32_t CountLines(); + + char *m_text; + size_t m_length; + uint32_t m_numLines; +}; + +#endif diff --git a/src/framework/util/hashing.cpp b/src/framework/util/hashing.cpp new file mode 100644 index 0000000..aef879a --- /dev/null +++ b/src/framework/util/hashing.cpp @@ -0,0 +1,59 @@ +#include "../debug.h" + +#include "hashing.h" + +#include +#include + +HashedValue HashString(const char *str) +{ + STACK_TRACE; + const unsigned long base = 65521L; + const unsigned long nmax = 5552; + +#define D01(buf, i) { s1 += tolower(buf[i]); s2 += s1; } +#define D02(buf, i) D01(buf, i); D01(buf, i + 1); +#define D04(buf, i) D02(buf, i); D02(buf, i + 2); +#define D08(buf, i) D04(buf, i); D04(buf, i + 4); +#define D016(buf) D08(buf, 0); D08(buf, 8); + + if (str == NULL) + return 0; + + unsigned long s1 = 0; + unsigned long s2 = 0; + + for (size_t len = strlen(str); len > 0; ) + { + unsigned long k = len < nmax ? len : nmax; + len -= k; + + while (k >= 16) + { + D016(str); + str += 16; + k -= 16; + } + + if (k != 0) + { + do + { + s1 += *str++; + s2 += s1; + } + while (--k); + } + + s1 %= base; + s2 %= base; + } + +#undef D01 +#undef D02 +#undef D04 +#undef D08 +#undef D016 + + return reinterpret_cast((s2 << 16) | s1); +} diff --git a/src/framework/util/hashing.h b/src/framework/util/hashing.h new file mode 100644 index 0000000..44fb6df --- /dev/null +++ b/src/framework/util/hashing.h @@ -0,0 +1,8 @@ +#ifndef __FRAMEWORK_UTILS_HASHING_H_INCLUDED__ +#define __FRAMEWORK_UTILS_HASHING_H_INCLUDED__ + +typedef void* HashedValue; + +HashedValue HashString(const char *str); + +#endif diff --git a/src/framework/util/msgbox.cpp b/src/framework/util/msgbox.cpp new file mode 100644 index 0000000..6423ff8 --- /dev/null +++ b/src/framework/util/msgbox.cpp @@ -0,0 +1,273 @@ +#include "../common.h" + +#include "msgbox.h" +#include + +#ifdef DESKTOP + #ifdef _WIN32 + #define MSGBOX_WINDOWS + #elif defined __APPLE__ + #define MSGBOX_OSX + #elif defined __linux__ + #define MSGBOX_LINUX + #endif +#endif + +enum MSGBOX_BUTTONS +{ + MSGBOX_BUTTON_OK = 1, + MSGBOX_BUTTON_CANCEL = 2, + MSGBOX_BUTTON_YES = 4, + MSGBOX_BUTTON_NO = 8, + MSGBOX_BUTTON_ABORT = 16, + MSGBOX_BUTTON_RETRY = 32, + MSGBOX_BUTTON_IGNORE = 64 +}; + +uint32_t ConvertMsgBoxTypeToSysMsgBoxIcon(MSGBOX_TYPE type); + +#ifdef MSGBOX_WINDOWS + + #define WIN32_LEAN_AND_MEAN + #define WIN32_EXTRA_LEAN + #include + + MSGBOX_RESULT SystemMessageBox(const stl::string& message, const stl::string& caption, uint32_t flags); + +#elif defined MSGBOX_OSX + + #include + + int SystemMessageBox(const stl::string& message, const stl::string& caption, CFOptionFlags flags, const char* firstButtonText, const char* secondButtonText = NULL, const char* thirdButtonText = NULL); + +#elif defined MSGBOX_LINUX + // TODO +#endif + +MSGBOX_RESULT MsgBox_Ok(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption) +{ + MSGBOX_RESULT result = MSGBOX_RESULT_UNKNOWN; + uint32_t icon = ConvertMsgBoxTypeToSysMsgBoxIcon(type); + +#ifdef MSGBOX_WINDOWS + result = SystemMessageBox(message, caption, MB_OK | icon); +#elif defined MSGBOX_OSX + int clicked = SystemMessageBox(message, caption, icon, "OK"); + if (clicked == 0) + result = MSGBOX_RESULT_OK; + else + result = MSGBOX_RESULT_UNKNOWN; +#elif defined MSGBOX_LINUX + // TODO +#endif + return result; +} + +MSGBOX_RESULT MsgBox_OkCancel(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption) +{ + MSGBOX_RESULT result = MSGBOX_RESULT_UNKNOWN; + uint32_t icon = ConvertMsgBoxTypeToSysMsgBoxIcon(type); + +#ifdef MSGBOX_WINDOWS + result = SystemMessageBox(message, caption, MB_OKCANCEL | icon); +#elif defined MSGBOX_OSX + int clicked = SystemMessageBox(message, caption, icon, "OK", "Cancel"); + switch (clicked) + { + case 0: + result = MSGBOX_RESULT_OK; + break; + case 1: + result = MSGBOX_RESULT_CANCEL; + break; + default: + result = MSGBOX_RESULT_UNKNOWN; + } +#elif defined MSGBOX_LINUX + // TODO +#endif + return result; +} + +MSGBOX_RESULT MsgBox_YesNo(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption) +{ + MSGBOX_RESULT result = MSGBOX_RESULT_UNKNOWN; + uint32_t icon = ConvertMsgBoxTypeToSysMsgBoxIcon(type); + +#ifdef MSGBOX_WINDOWS + result = SystemMessageBox(message, caption, MB_YESNO | icon); +#elif defined MSGBOX_OSX + int clicked = SystemMessageBox(message, caption, icon, "Yes", "No"); + switch (clicked) + { + case 0: + result = MSGBOX_RESULT_YES; + break; + case 1: + result = MSGBOX_RESULT_NO; + break; + default: + result = MSGBOX_RESULT_UNKNOWN; + } +#elif defined MSGBOX_LINUX + // TODO +#endif + return result; +} + +MSGBOX_RESULT MsgBox_AbortRetryIgnore(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption) +{ + MSGBOX_RESULT result = MSGBOX_RESULT_UNKNOWN; + uint32_t icon = ConvertMsgBoxTypeToSysMsgBoxIcon(type); + +#ifdef MSGBOX_WINDOWS + result = SystemMessageBox(message, caption, MB_ABORTRETRYIGNORE | icon); +#elif defined MSGBOX_OSX + int clicked = SystemMessageBox(message, caption, icon, "Abort", "Retry", "Ignore"); + switch (clicked) + { + case 0: + result = MSGBOX_RESULT_ABORT; + break; + case 1: + result = MSGBOX_RESULT_RETRY; + break; + case 2: + result = MSGBOX_RESULT_IGNORE; + break; + default: + result = MSGBOX_RESULT_UNKNOWN; + } +#elif defined MSGBOX_LINUX + // TODO +#endif + return result; +} + +uint32_t ConvertMsgBoxTypeToSysMsgBoxIcon(MSGBOX_TYPE type) +{ + switch (type) + { + case MSGBOX_TYPE_PLAIN: +#ifdef MSGBOX_WINDOWS + return 0; +#elif defined MSGBOX_OSX + return kCFUserNotificationPlainAlertLevel; +#elif defined MSGBOX_LINUX + // TODO +#else + return 0; +#endif + break; + case MSGBOX_TYPE_PROMPT: +#ifdef MSGBOX_WINDOWS + return MB_ICONQUESTION; +#elif defined MSGBOX_OSX + return kCFUserNotificationNoteAlertLevel; +#elif defined MSGBOX_LINUX + // TODO +#else + return 0; +#endif + break; + case MSGBOX_TYPE_WARNING: +#ifdef MSGBOX_WINDOWS + return MB_ICONEXCLAMATION; +#elif defined MSGBOX_OSX + return kCFUserNotificationCautionAlertLevel; +#elif defined MSGBOX_LINUX + // TODO +#else + return 0; +#endif + break; + case MSGBOX_TYPE_ERROR: +#ifdef MSGBOX_WINDOWS + return MB_ICONERROR; +#elif defined MSGBOX_OSX + return kCFUserNotificationStopAlertLevel; +#elif defined MSGBOX_LINUX + // TODO +#else + return 0; +#endif + break; + default: + return 0; + } +} + +#ifdef MSGBOX_WINDOWS +MSGBOX_RESULT SystemMessageBox(const stl::string& message, const stl::string& caption, uint32_t flags) +{ + int result = MessageBoxA(NULL, message.c_str(), caption.c_str(), flags); + + switch (result) + { + case IDOK: return MSGBOX_RESULT_OK; + case IDCANCEL: return MSGBOX_RESULT_CANCEL; + case IDYES: return MSGBOX_RESULT_YES; + case IDNO: return MSGBOX_RESULT_NO; + case IDABORT: return MSGBOX_RESULT_ABORT; + case IDRETRY: return MSGBOX_RESULT_RETRY; + case IDIGNORE: return MSGBOX_RESULT_IGNORE; + } + + return MSGBOX_RESULT_UNKNOWN; +} +#elif defined MSGBOX_OSX +int SystemMessageBox(const stl::string& message, const stl::string& caption, CFOptionFlags flags, const char* firstButtonText, const char* secondButtonText, const char* thirdButtonText) +{ + CFStringRef captionRef = CFStringCreateWithCString(NULL, caption.c_str(), kCFStringEncodingUTF8); + CFStringRef messageRef = CFStringCreateWithCString(NULL, message.c_str(), kCFStringEncodingUTF8); + + CFStringRef firstButton = NULL; + if (firstButtonText != NULL) + firstButton = CFStringCreateWithCString(NULL, firstButtonText, strlen(firstButtonText)); + + CFStringRef secondButton = NULL; + if (secondButtonText != NULL) + secondButton = CFStringCreateWithCString(NULL, secondButtonText, strlen(secondButtonText)); + + CFStringRef thirdButton = NULL; + if (thirdButtonText != NULL) + thirdButton = CFStringCreateWithCString(NULL, thirdButtonText, strlen(thirdButtonText)); + + CFOptionFlags result; + + CFUserNotificationDisplayAlert( + 0, + flags, + NULL, + NULL, + NULL, + captionRef, + messageRef, + firstButton, + secondButton, + thirdButton, + &result + ); + + CFRelease(captionRef); + CFRelease(messageRef); + + if (firstButton != NULL) + CFRelease(firstButton); + if (secondButton != NULL) + CFRelease(secondButton); + if (thirdButton != NULL) + CFRelease(thirdButton); + + switch (result) + { + case kCFUserNotificationDefaultResponse: return 0; + case kCFUserNotificationAlternateResponse: return 1; + case kCFUserNotificationOtherResponse: return 2; + } + + return -1; +} +#elif defined MSGBOX_LINUX + // TODO +#endif diff --git a/src/framework/util/msgbox.h b/src/framework/util/msgbox.h new file mode 100644 index 0000000..17ef1aa --- /dev/null +++ b/src/framework/util/msgbox.h @@ -0,0 +1,31 @@ +#ifndef __FRAMEWORK_UTIL_MSGBOX_H_INCLUDED__ +#define __FRAMEWORK_UTIL_MSGBOX_H_INCLUDED__ + +#include + +enum MSGBOX_TYPE +{ + MSGBOX_TYPE_PLAIN, + MSGBOX_TYPE_PROMPT, + MSGBOX_TYPE_WARNING, + MSGBOX_TYPE_ERROR +}; + +enum MSGBOX_RESULT +{ + MSGBOX_RESULT_UNKNOWN, + MSGBOX_RESULT_OK, + MSGBOX_RESULT_CANCEL, + MSGBOX_RESULT_YES, + MSGBOX_RESULT_NO, + MSGBOX_RESULT_ABORT, + MSGBOX_RESULT_RETRY, + MSGBOX_RESULT_IGNORE +}; + +MSGBOX_RESULT MsgBox_Ok(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption); +MSGBOX_RESULT MsgBox_OkCancel(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption); +MSGBOX_RESULT MsgBox_YesNo(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption); +MSGBOX_RESULT MsgBox_AbortRetryIgnore(MSGBOX_TYPE type, const stl::string& message, const stl::string& caption); + +#endif diff --git a/src/game/debuginfoprocess.cpp b/src/game/debuginfoprocess.cpp new file mode 100644 index 0000000..30ac827 --- /dev/null +++ b/src/game/debuginfoprocess.cpp @@ -0,0 +1,53 @@ +#include "../framework/debug.h" + +#include "debuginfoprocess.h" + +#include "../gameapp.h" +#include "../contexts/contentcache.h" +#include "../contexts/rendercontext.h" +#include "../entities/entity.h" +#include "../entities/entitymanager.h" +#include "../framework/content/contentmanager.h" +#include "../framework/content/spritefontparam.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/spritebatch.h" +#include "../framework/graphics/spritefont.h" +#include "../framework/graphics/viewcontext.h" +#include "../framework/math/camera.h" +#include "../states/gamestate.h" +#include + +const Color TEXT_COLOR = COLOR_WHITE; + +DebugInfoProcess::DebugInfoProcess(GameState *gameState, ProcessManager *processManager) + : GameProcess(gameState, processManager) +{ + STACK_TRACE; +} + +DebugInfoProcess::~DebugInfoProcess() +{ + STACK_TRACE; +} + +void DebugInfoProcess::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + SpriteFont *font = GetGameApp()->GetContentCache()->GetUIFont(); + + uint16_t y = 5; + renderContext->GetSpriteBatch()->Printf(font, 5, y, TEXT_COLOR, "Loops: %d\nFT: %.6fs\nRPS: %d (%d)\nUPS: %d (%d)", + GetGameApp()->GetFPS(), + GetGameApp()->GetFrameTime(), + GetGameApp()->GetRendersPerSecond(), GetGameApp()->GetRenderTime(), + GetGameApp()->GetUpdatesPerSecond(), GetGameApp()->GetUpdateTime() + ); + y += font->GetLetterHeight() * 3; + + renderContext->GetSpriteBatch()->Printf(font, 5, (y += font->GetLetterHeight()), TEXT_COLOR, "UI Scale: %d", GetGameApp()->GetScreenScale()); + renderContext->GetSpriteBatch()->Printf(font, 5, (y += font->GetLetterHeight()), TEXT_COLOR, "CP: %f, %f, %f", + renderContext->GetGraphicsDevice()->GetViewContext()->GetCamera()->GetPosition().x, + renderContext->GetGraphicsDevice()->GetViewContext()->GetCamera()->GetPosition().y, + renderContext->GetGraphicsDevice()->GetViewContext()->GetCamera()->GetPosition().z + ); +} diff --git a/src/game/debuginfoprocess.h b/src/game/debuginfoprocess.h new file mode 100644 index 0000000..fe47844 --- /dev/null +++ b/src/game/debuginfoprocess.h @@ -0,0 +1,27 @@ +#ifndef __GAME_DEBUGINFOPROCESS_H_INCLUDED__ +#define __GAME_DEBUGINFOPROCESS_H_INCLUDED__ + +#include "../processes/gameprocess.h" + +class GameState; +class ProcessManager; +class RenderContext; + +class DebugInfoProcess : public GameProcess +{ +public: + static GAMEPROCESS_TYPE GetType() + { + static GAMEPROCESS_TYPE typeName = "DebugInfoProcess"; + return typeName; + } + GAMEPROCESS_TYPE GetTypeOf() const { return GetType(); } + + DebugInfoProcess(GameState *gameState, ProcessManager *processManager); + virtual ~DebugInfoProcess(); + + void OnRender(RenderContext *renderContext); +}; + +#endif + diff --git a/src/game/testingstate.cpp b/src/game/testingstate.cpp new file mode 100644 index 0000000..a2eeb9f --- /dev/null +++ b/src/game/testingstate.cpp @@ -0,0 +1,129 @@ +#include "../framework/debug.h" +#include "../framework/log.h" +#include "../framework/common.h" + +#include "testingstate.h" + +#include "debuginfoprocess.h" +#include "../gameapp.h" +#include "../contexts/rendercontext.h" +#include "../framework/graphics/color.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/simplecolorshader.h" +#include "../framework/graphics/viewcontext.h" +#include "../framework/input/keyboard.h" +#include "../framework/math/camera.h" +#include "../framework/math/common.h" +#include "../framework/support/freecamera.h" +#include "../framework/support/grid.h" +#include "../processes/processmanager.h" + +TestingState::TestingState(GameApp *gameApp, StateManager *stateManager) + : GameState(gameApp, stateManager) +{ + STACK_TRACE; + m_grid = NULL; + m_camera = NULL; +} + +TestingState::~TestingState() +{ + STACK_TRACE; +} + +void TestingState::OnPush() +{ + STACK_TRACE; + m_camera = new FreeCamera(GetGameApp()->GetGraphicsDevice()->GetViewContext(), GetGameApp()); + m_camera->GetPosition().Set(0.0f, 1.0f, 0.0f); + GetGameApp()->GetGraphicsDevice()->GetViewContext()->SetCamera(m_camera); + + m_grid = new Grid(GetGameApp()->GetGraphicsDevice(), 32, 32); + + GetProcessManager()->Add(); +} + +void TestingState::OnPop() +{ + STACK_TRACE; + GetGameApp()->GetGraphicsDevice()->GetViewContext()->SetCamera(NULL); + + SAFE_DELETE(m_grid); + SAFE_DELETE(m_camera); +} + +void TestingState::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + GameState::OnPause(dueToOverlay); +} + +void TestingState::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + GameState::OnResume(fromOverlay); +} + +void TestingState::OnAppGainFocus() +{ + STACK_TRACE; + GameState::OnAppGainFocus(); +} + +void TestingState::OnAppLostFocus() +{ + STACK_TRACE; + GameState::OnAppLostFocus(); +} + +void TestingState::OnLostContext() +{ + STACK_TRACE; + GameState::OnLostContext(); +} + +void TestingState::OnNewContext() +{ + STACK_TRACE; + GameState::OnNewContext(); +} + +void TestingState::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + SimpleColorShader *colorShader = renderContext->GetGraphicsDevice()->GetSimpleColorShader(); + + renderContext->GetGraphicsDevice()->Clear(0.25f, 0.5f, 1.0f, 1.0f); + + renderContext->GetGraphicsDevice()->BindShader(colorShader); + colorShader->SetModelViewMatrix(renderContext->GetGraphicsDevice()->GetViewContext()->GetModelViewMatrix()); + colorShader->SetProjectionMatrix(renderContext->GetGraphicsDevice()->GetViewContext()->GetProjectionMatrix()); + m_grid->OnRender(); + renderContext->GetGraphicsDevice()->UnbindShader(); + + + GameState::OnRender(renderContext); +} + +void TestingState::OnResize() +{ + STACK_TRACE; + GameState::OnResize(); +} + +void TestingState::OnUpdate(float delta) +{ + STACK_TRACE; + GameState::OnUpdate(delta); + + if (GetGameApp()->GetKeyboard()->IsPressed(KSYM_ESCAPE)) + SetFinished(); + + GetGameApp()->GetGraphicsDevice()->GetViewContext()->GetCamera()->OnUpdate(delta); +} + +BOOL TestingState::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return TRUE; +} diff --git a/src/game/testingstate.h b/src/game/testingstate.h new file mode 100644 index 0000000..243c6e5 --- /dev/null +++ b/src/game/testingstate.h @@ -0,0 +1,44 @@ +#ifndef __GAME_TESTINGSTATE_H_INCLUDED__ +#define __GAME_TESTINGSTATE_H_INCLUDED__ + +#include "../states/gamestate.h" + +class FreeCamera; +class GameApp; +class Grid; +class RenderContext; +class StateManager; + +class TestingState : public GameState +{ +public: + static GAMESTATE_TYPE GetType() + { + static GAMESTATE_TYPE typeName = "TestingState"; + return typeName; + } + GAMESTATE_TYPE GetTypeOf() const { return GetType(); } + + TestingState(GameApp *gameApp, StateManager *stateManager); + virtual ~TestingState(); + + void OnPush(); + void OnPop(); + void OnPause(BOOL dueToOverlay); + void OnResume(BOOL fromOverlay); + void OnAppGainFocus(); + void OnAppLostFocus(); + void OnLostContext(); + void OnNewContext(); + void OnRender(RenderContext *renderContext); + void OnResize(); + void OnUpdate(float delta); + BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + +private: + Grid *m_grid; + FreeCamera *m_camera; +}; + +#endif + diff --git a/src/gameapp.cpp b/src/gameapp.cpp new file mode 100644 index 0000000..4ea7f88 --- /dev/null +++ b/src/gameapp.cpp @@ -0,0 +1,174 @@ +#include "framework/debug.h" +#include "framework/log.h" + +#include "gameapp.h" + +#include "contexts/contentcache.h" +#include "contexts/rendercontext.h" +#include "events/eventmanager.h" +#include "framework/sdlgamewindow.h" +#include "framework/marmaladegamewindow.h" +#include "framework/content/contentmanager.h" +#include "framework/content/imageloader.h" +#include "framework/content/keyframemeshloader.h" +#include "framework/content/skeletalmeshloader.h" +#include "framework/content/spritefontloader.h" +#include "framework/content/staticmeshloader.h" +#include "framework/content/textloader.h" +#include "framework/content/textureloader.h" +#include "framework/graphics/graphicsdevice.h" +#include "framework/graphics/textureparameters.h" +#include "framework/graphics/viewcontext.h" +#include "game/testingstate.h" +#include "states/statemanager.h" + +GameApp::GameApp() + : BaseGameApp() +{ + STACK_TRACE; + m_contentCache = NULL; + m_renderContext = NULL; + m_stateManager = NULL; + m_eventManager = NULL; +} + +GameApp::~GameApp() +{ + STACK_TRACE; + SAFE_DELETE(m_stateManager); + SAFE_DELETE(m_eventManager); + SAFE_DELETE(m_contentCache); + SAFE_DELETE(m_renderContext); +} + +void GameApp::OnAppGainFocus() +{ + STACK_TRACE; + BaseGameApp::OnAppGainFocus(); + m_stateManager->OnAppGainFocus(); +} + +void GameApp::OnAppLostFocus() +{ + STACK_TRACE; + BaseGameApp::OnAppLostFocus(); + m_stateManager->OnAppLostFocus(); +} + +void GameApp::OnAppPause() +{ + STACK_TRACE; + BaseGameApp::OnAppPause(); + m_stateManager->OnAppPause(); +} + +void GameApp::OnAppResume() +{ + STACK_TRACE; + BaseGameApp::OnAppResume(); + m_stateManager->OnAppResume(); +} + +BOOL GameApp::OnInit() +{ + STACK_TRACE; + +#if defined(DESKTOP) && defined(SDL) + SDLGameWindowParams windowParams; + windowParams.title = "Engine Test"; + windowParams.width = 854; + windowParams.height = 480; + windowParams.bpp = 0; + windowParams.windowed = TRUE; + windowParams.resizable = TRUE; +#elif MOBILE + GameWindowParams windowParams; + windowParams.windowed = FALSE; +#else +#error Undefined platform. +#endif + + if (!Initialize(&windowParams)) + return FALSE; + + SeedRnd(GetOperatingSystem()->GetTicks()); + + GetContentManager()->RegisterLoader(new ImageLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new KeyframeMeshLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new SkeletalMeshLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new SpriteFontLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new StaticMeshLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new TextLoader(GetContentManager())); + GetContentManager()->RegisterLoader(new TextureLoader(GetContentManager())); + + m_eventManager = new EventManager(); + m_stateManager = new StateManager(this); + m_renderContext = new RenderContext(GetGraphicsDevice(), GetContentManager()); + m_contentCache = new ContentCache(GetContentManager()); + + return TRUE; +} + +void GameApp::OnLoadGame() +{ + STACK_TRACE; + GetGraphicsDevice()->SetTextureParameters(TEXPARAM_PIXELATED); + + m_renderContext->OnLoadGame(); + m_contentCache->OnLoadGame(); + + m_stateManager->Push(); +} + +void GameApp::OnLostContext() +{ + STACK_TRACE; + BaseGameApp::OnLostContext(); + m_stateManager->OnLostContext(); +} + +void GameApp::OnNewContext() +{ + STACK_TRACE; + BaseGameApp::OnNewContext(); + m_stateManager->OnNewContext(); +} + +void GameApp::OnRender() +{ + STACK_TRACE; + BaseGameApp::OnRender(); + m_renderContext->OnPreRender(); + m_stateManager->OnRender(m_renderContext); + m_renderContext->OnPostRender(); +} + +void GameApp::OnResize() +{ + STACK_TRACE; + BaseGameApp::OnResize(); + m_renderContext->OnResize(); + m_stateManager->OnResize(); +} + +void GameApp::OnUpdate(float delta) +{ + STACK_TRACE; + BaseGameApp::OnUpdate(delta); + + m_eventManager->ProcessQueue(); + + m_stateManager->OnUpdate(delta); + + if (m_stateManager->IsEmpty()) + { + LOG_INFO(LOGCAT_GAMEAPP, "No states running, quitting.\n"); + Quit(); + } +} + +uint32_t GameApp::GetScreenScale() const +{ + STACK_TRACE; + return m_renderContext->GetScreenScale(); +} diff --git a/src/gameapp.h b/src/gameapp.h new file mode 100644 index 0000000..1780fdd --- /dev/null +++ b/src/gameapp.h @@ -0,0 +1,43 @@ +#ifndef __GAMEAPP_H_INCLUDED__ +#define __GAMEAPP_H_INCLUDED__ + +#include "framework/common.h" +#include "framework/basegameapp.h" +#include "contexts/rendercontext.h" + +class ContentCache; +class EventManager; +class StateManager; + +class GameApp : public BaseGameApp +{ +public: + GameApp(); + virtual ~GameApp(); + + void OnAppGainFocus(); + void OnAppLostFocus(); + void OnAppPause(); + void OnAppResume(); + BOOL OnInit(); + void OnLoadGame(); + void OnLostContext(); + void OnNewContext(); + void OnRender(); + void OnResize(); + void OnUpdate(float delta); + + ContentCache* GetContentCache() const { return m_contentCache; } + StateManager* GetStateManager() const { return m_stateManager; } + EventManager* GetEventManager() const { return m_eventManager; } + + uint32_t GetScreenScale() const; + +private: + ContentCache *m_contentCache; + RenderContext *m_renderContext; + StateManager *m_stateManager; + EventManager *m_eventManager; +}; + +#endif diff --git a/src/graphics/textureanimator.cpp b/src/graphics/textureanimator.cpp new file mode 100644 index 0000000..1ddfb42 --- /dev/null +++ b/src/graphics/textureanimator.cpp @@ -0,0 +1,222 @@ +#include "../framework/debug.h" + +#include "textureanimator.h" +#include "textureatlasanimationsequence.h" +#include "../framework/content/contentmanager.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/image.h" +#include "../framework/graphics/texture.h" +#include "../framework/graphics/textureatlas.h" +#include + +TextureAnimator::TextureAnimator(ContentManager *contentManager, GraphicsDevice *graphicsDevice) +{ + STACK_TRACE; + m_contentManager = contentManager; + m_graphicsDevice = graphicsDevice; +} + +TextureAnimator::~TextureAnimator() +{ + STACK_TRACE; + ResetAll(); +} + +void TextureAnimator::ResetAll() +{ + for (TextureAtlasAnimations::iterator i = m_textureAtlasAnimations.begin(); i != m_textureAtlasAnimations.end(); ++i) + { + TextureAtlasAnimationSequence &sequence = *i; + if (sequence.originalAnimatingTile != NULL) + { + RestoreTextureWithOriginalTile(sequence); + SAFE_DELETE(sequence.originalAnimatingTile); + } + if (sequence.frames != NULL) + { + for (uint32_t i = 0; i < sequence.GetNumFrames(); ++i) + { + Image *frame = sequence.frames[i]; + SAFE_DELETE(frame); + } + } + } + + m_textureAtlasAnimations.clear(); +} + +void TextureAnimator::AddTileSequence(TextureAtlas *atlas, uint32_t tileToBeAnimated, uint32_t start, uint32_t stop, float delay, BOOL loop) +{ + STACK_TRACE; + AddTileSequence("", atlas, tileToBeAnimated, start, stop, delay, loop); +} + +void TextureAnimator::AddTileSequence(const stl::string &name, TextureAtlas *atlas, uint32_t tileToBeAnimated, uint32_t start, uint32_t stop, float delay, BOOL loop) +{ + STACK_TRACE; + ASSERT(atlas != NULL); + ASSERT(tileToBeAnimated < atlas->GetNumTextures()); + ASSERT(start < atlas->GetNumTextures()); + ASSERT(stop < atlas->GetNumTextures()); + ASSERT(start < stop); + ASSERT((tileToBeAnimated >= start && tileToBeAnimated <= stop) == FALSE); + + TextureAtlasAnimationSequence *existingSequence = FindTileSequenceByName(name); + ASSERT(existingSequence == NULL); + if (existingSequence != NULL) + return; + + TextureAtlasAnimationSequence sequence; + sequence.atlas = atlas; + sequence.animatingIndex = tileToBeAnimated; + sequence.start = start; + sequence.stop = stop; + sequence.delay = delay; + sequence.isAnimating = TRUE; + sequence.loop = loop; + sequence.frames = new Image*[sequence.GetNumFrames()]; + sequence.name = name; + + sequence.current = sequence.start; + sequence.currentFrameTime = 0.0f; + + // since we can't read a texture back from OpenGL after we've uploaded it + // (??? or can we somehow .. ?), we need to load the image again so that + // we can copy out the image data for tiles "start" to "stop" + stl::string textureFilename = m_contentManager->GetNameOf((Texture*)atlas->GetTexture()); + Image *textureImage = m_contentManager->Get(textureFilename); + + // first, copy the original tile image that's at the "tileToBeAnimated" spot + // in the atlas texture so we can restore it back again if necessary + const TextureAtlasTile &originalTile = atlas->GetTile(sequence.animatingIndex); + sequence.originalAnimatingTile = new Image(); + sequence.originalAnimatingTile->Create(textureImage, originalTile.dimensions.left, originalTile.dimensions.top, originalTile.dimensions.right - 1, originalTile.dimensions.bottom - 1); + + // copy each frame ("start" to "stop") from the source texture image + for (uint32_t i = 0; i < sequence.GetNumFrames(); ++i) + { + const TextureAtlasTile &tile = atlas->GetTile(i + sequence.start); + sequence.frames[i] = new Image(); + sequence.frames[i]->Create(textureImage, tile.dimensions.left, tile.dimensions.top, tile.dimensions.right - 1, tile.dimensions.bottom - 1); + } + + m_textureAtlasAnimations.push_back(sequence); +} + +void TextureAnimator::ResetTileSequence(const stl::string &name) +{ + STACK_TRACE; + ASSERT(name.length() != 0); + + TextureAtlasAnimationSequence *existingSequence = FindTileSequenceByName(name); + ASSERT(existingSequence != NULL); + + existingSequence->isAnimating = TRUE; + existingSequence->current = existingSequence->start; + existingSequence->currentFrameTime = 0.0f; + + UpdateTextureWithCurrentTileFrame(*existingSequence); +} + +void TextureAnimator::StopTileSequence(const stl::string &name, BOOL restoreOriginalTile) +{ + STACK_TRACE; + ASSERT(name.length() != 0); + + TextureAtlasAnimationSequence *existingSequence = FindTileSequenceByName(name); + ASSERT(existingSequence != NULL); + + existingSequence->isAnimating = FALSE; + existingSequence->current = existingSequence->stop; + existingSequence->currentFrameTime = 0.0f; + + if (restoreOriginalTile) + RestoreTextureWithOriginalTile(*existingSequence); + else + UpdateTextureWithCurrentTileFrame(*existingSequence); +} + +void TextureAnimator::EnableTileSequence(const stl::string &name, BOOL enable) +{ + ASSERT(name.length() != 0); + + TextureAtlasAnimationSequence *existingSequence = FindTileSequenceByName(name); + ASSERT(existingSequence != NULL); + + existingSequence->isAnimating = enable; + existingSequence->currentFrameTime = 0.0f; + + UpdateTextureWithCurrentTileFrame(*existingSequence); +} + + +void TextureAnimator::OnUpdate(float delta) +{ + STACK_TRACE; + for (TextureAtlasAnimations::iterator i = m_textureAtlasAnimations.begin(); i != m_textureAtlasAnimations.end(); ++i) + { + TextureAtlasAnimationSequence &sequence = *i; + + if (!sequence.IsAnimationFinished() && sequence.isAnimating) + { + sequence.currentFrameTime += delta; + + if (sequence.currentFrameTime >= sequence.delay) + { + // move to the next frame + sequence.currentFrameTime = 0.0f; + + ++sequence.current; + if (sequence.current > sequence.stop) + sequence.current = sequence.start; + + UpdateTextureWithCurrentTileFrame(sequence); + } + } + } +} + +void TextureAnimator::OnNewContext() +{ + STACK_TRACE; + for (TextureAtlasAnimations::iterator i = m_textureAtlasAnimations.begin(); i != m_textureAtlasAnimations.end(); ++i) + { + TextureAtlasAnimationSequence &sequence = *i; + UpdateTextureWithCurrentTileFrame(sequence); + } +} + +TextureAtlasAnimationSequence* TextureAnimator::FindTileSequenceByName(const stl::string &name) +{ + STACK_TRACE; + if (name.length() == 0) + return NULL; + + for (TextureAtlasAnimations::iterator i = m_textureAtlasAnimations.begin(); i != m_textureAtlasAnimations.end(); ++i) + { + const TextureAtlasAnimationSequence &sequence = *i; + if (sequence.name == name) + return &(*i); + } + + return NULL; +} + +void TextureAnimator::UpdateTextureWithCurrentTileFrame(TextureAtlasAnimationSequence &sequence) +{ + STACK_TRACE; + uint32_t frameIndex = sequence.current - sequence.start; + ASSERT(frameIndex < sequence.GetNumFrames()); + Image *frameImage = sequence.frames[frameIndex]; + const TextureAtlasTile &tile = sequence.atlas->GetTile(sequence.animatingIndex); + + sequence.atlas->GetTexture()->Update(frameImage, tile.dimensions.left, tile.dimensions.top); +} + +void TextureAnimator::RestoreTextureWithOriginalTile(TextureAtlasAnimationSequence &sequence) +{ + STACK_TRACE; + const TextureAtlasTile &tile = sequence.atlas->GetTile(sequence.animatingIndex); + sequence.atlas->GetTexture()->Update(sequence.originalAnimatingTile, tile.dimensions.left, tile.dimensions.top); +} + diff --git a/src/graphics/textureanimator.h b/src/graphics/textureanimator.h new file mode 100644 index 0000000..0396cd2 --- /dev/null +++ b/src/graphics/textureanimator.h @@ -0,0 +1,45 @@ +#ifndef __GRAPHICS_TEXTUREANIMATOR_H_INCLUDED__ +#define __GRAPHICS_TEXTUREANIMATOR_H_INCLUDED__ + +#include "../framework/common.h" +#include "textureatlasanimationsequence.h" +#include +#include + +class ContentManager; +class GraphicsDevice; +class Image; +class Texture; +class TextureAtlas; + +typedef stl::list TextureAtlasAnimations; + +class TextureAnimator +{ +public: + TextureAnimator(ContentManager *contentManager, GraphicsDevice *graphicsDevice); + virtual ~TextureAnimator(); + + void ResetAll(); + + void AddTileSequence(TextureAtlas *atlas, uint32_t tileToBeAnimated, uint32_t start, uint32_t stop, float delay, BOOL loop = TRUE); + void AddTileSequence(const stl::string &name, TextureAtlas *atlas, uint32_t tileToBeAnimated, uint32_t start, uint32_t stop, float delay, BOOL loop = TRUE); + void ResetTileSequence(const stl::string &name); + void StopTileSequence(const stl::string &name, BOOL restoreOriginalTile = FALSE); + void EnableTileSequence(const stl::string &name, BOOL enable); + + void OnUpdate(float delta); + void OnNewContext(); + +private: + TextureAtlasAnimationSequence* FindTileSequenceByName(const stl::string &name); + void UpdateTextureWithCurrentTileFrame(TextureAtlasAnimationSequence &sequence); + void RestoreTextureWithOriginalTile(TextureAtlasAnimationSequence &sequence); + + ContentManager *m_contentManager; + GraphicsDevice *m_graphicsDevice; + TextureAtlasAnimations m_textureAtlasAnimations; +}; + +#endif + diff --git a/src/graphics/textureatlasanimationsequence.h b/src/graphics/textureatlasanimationsequence.h new file mode 100644 index 0000000..4d6e3dc --- /dev/null +++ b/src/graphics/textureatlasanimationsequence.h @@ -0,0 +1,60 @@ +#ifndef __GRAPHICS_TEXTUREATLASANIMATIONSEQUENCE_H_INCLUDED__ +#define __GRAPHICS_TEXTUREATLASANIMATIONSEQUENCE_H_INCLUDED__ + +#include "../framework/common.h" +#include + +class Image; +class TextureAtlas; + +struct TextureAtlasAnimationSequence +{ + TextureAtlas *atlas; + uint32_t animatingIndex; + uint32_t start; + uint32_t stop; + uint32_t current; + float delay; + float currentFrameTime; + BOOL isAnimating; + BOOL loop; + Image *originalAnimatingTile; + Image **frames; + stl::string name; + + TextureAtlasAnimationSequence(); + + uint32_t GetNumFrames() const; + BOOL IsAnimationFinished() const; +}; + +inline TextureAtlasAnimationSequence::TextureAtlasAnimationSequence() +{ + atlas = NULL; + animatingIndex = 0; + start = 0; + stop = 0; + current = 0; + delay = 0.0f; + currentFrameTime = 0.0f; + isAnimating = FALSE; + loop = FALSE; + originalAnimatingTile = NULL; + frames = NULL; +} + +inline uint32_t TextureAtlasAnimationSequence::GetNumFrames() const +{ + return stop - start + 1; +} + +inline BOOL TextureAtlasAnimationSequence::IsAnimationFinished() const +{ + if (isAnimating && !loop && current == stop) + return TRUE; + else + return FALSE; +} + +#endif + diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..7530855 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,76 @@ +#include "gameapp.h" +#include "framework/common.h" +#include "framework/debug.h" +#include "framework/log.h" +#include "framework/operatingsystem.h" +#include "framework/file/util.h" +#include +#include + +#if defined(DESKTOP) && defined(SDL) +#include "framework/sdlsystem.h" +#elif MOBILE +#include "framework/marmaladesystem.h" +#else +#error Unknown platform +#endif + +int main(int argc, char **argv) +{ + STACK_TRACE; + + LogStart(); + DebugInit(); + LOG_INFO(LOGCAT_SYSTEM, "Build compiled on %s %s\n", __DATE__, __TIME__); +#ifdef DESKTOP + LOG_INFO(LOGCAT_SYSTEM, "App path is: %s\n", GetAppPath().c_str()); +#endif + + OperatingSystem *system = NULL; + +#if defined(DESKTOP) && defined(SDL) + system = new SDLSystem(); +#elif MOBILE + system = new MarmaladeSystem(); +#else +#error Unknown platform +#endif + + ASSERT(system != NULL); + + if (!system->Initialize()) + { + SAFE_DELETE(system); + + LOG_ERROR(LOGCAT_SYSTEM, "Initialization failed. Exiting.\n"); + DebugClose(); + LogEnd(); + + return 1; + } + + GameApp *app = new GameApp(); + + if (!app->Start(system)) + { + SAFE_DELETE(app); + SAFE_DELETE(system); + + LOG_ERROR(LOGCAT_SYSTEM, "Error while starting GameApp. Exiting.\n"); + DebugClose(); + LogEnd(); + + return 1; + } + + app->Loop(); + + SAFE_DELETE(app); + SAFE_DELETE(system); + + LOG_INFO(LOGCAT_SYSTEM, "Finished successfully.\n"); + DebugClose(); + LogEnd(); + + return 0; +} diff --git a/src/processes/gameprocess.cpp b/src/processes/gameprocess.cpp new file mode 100644 index 0000000..5a53499 --- /dev/null +++ b/src/processes/gameprocess.cpp @@ -0,0 +1,111 @@ +#include "../framework/debug.h" + +#include "gameprocess.h" + +#include "processmanager.h" +#include "../gameapp.h" +#include "../states/gamestate.h" + +GameProcess::GameProcess(GameState *gameState, ProcessManager *processManager) + : EventListenerEx(gameState->GetGameApp()->GetEventManager()) +{ + STACK_TRACE; + m_gameState = gameState; + m_processManager = processManager; + m_finished = FALSE; +} + +GameProcess::~GameProcess() +{ + STACK_TRACE; +} + +void GameProcess::OnAdd() +{ + STACK_TRACE; +} + +void GameProcess::OnRemove() +{ + STACK_TRACE; +} + +void GameProcess::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; +} + +void GameProcess::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; +} + +void GameProcess::OnAppGainFocus() +{ + STACK_TRACE; +} + +void GameProcess::OnAppLostFocus() +{ + STACK_TRACE; +} + +void GameProcess::OnAppPause() +{ + STACK_TRACE; +} + +void GameProcess::OnAppResume() +{ + STACK_TRACE; +} + +void GameProcess::OnLostContext() +{ + STACK_TRACE; +} + +void GameProcess::OnNewContext() +{ + STACK_TRACE; +} + +void GameProcess::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; +} + +void GameProcess::OnResize() +{ + STACK_TRACE; +} + +void GameProcess::OnUpdate(float delta) +{ + STACK_TRACE; +} + +BOOL GameProcess::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return TRUE; +} + +BOOL GameProcess::Handle(const Event *event) +{ + STACK_TRACE; + return FALSE; +} + +BOOL GameProcess::IsTransitioning() const +{ + STACK_TRACE; + return m_processManager->IsTransitioning(this); +} + +void GameProcess::SetFinished() +{ + STACK_TRACE; + m_finished = TRUE; +} + diff --git a/src/processes/gameprocess.h b/src/processes/gameprocess.h new file mode 100644 index 0000000..425823a --- /dev/null +++ b/src/processes/gameprocess.h @@ -0,0 +1,93 @@ +#ifndef __PROCESSES_GAMEPROCESS_H_INCLUDED__ +#define __PROCESSES_GAMEPROCESS_H_INCLUDED__ + +#include "../framework/common.h" + +#include "../states/gamestate.h" +#include "../events/eventlistenerex.h" + +typedef const char* GAMEPROCESS_TYPE; + +class GameApp; +class ProcessManager; +class RenderContext; +struct Event; + +class GameProcess : public EventListenerEx +{ +public: + GameProcess(GameState *gameState, ProcessManager *processManager); + virtual ~GameProcess(); + + virtual void OnAdd(); + virtual void OnRemove(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnAppGainFocus(); + virtual void OnAppLostFocus(); + virtual void OnAppPause(); + virtual void OnAppResume(); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + virtual BOOL Handle(const Event *event); + + virtual GAMEPROCESS_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(GAMEPROCESS_TYPE type) const; + template T* As(); + template const T* As() const; + + GameApp* GetGameApp() const { return m_gameState->GetGameApp(); } + + BOOL IsFinished() const { return m_finished; } + BOOL IsTransitioning() const; + +protected: + GameState* GetGameState() const { return m_gameState; } + ProcessManager* GetProcessManager() const { return m_processManager; } + + void SetFinished(); + +private: + GameState* m_gameState; + ProcessManager *m_processManager; + BOOL m_finished; +}; + +template +inline BOOL GameProcess::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL GameProcess::Is(GAMEPROCESS_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* GameProcess::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* GameProcess::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/processes/gwengameprocess.cpp b/src/processes/gwengameprocess.cpp new file mode 100644 index 0000000..d80dcc9 --- /dev/null +++ b/src/processes/gwengameprocess.cpp @@ -0,0 +1,88 @@ +#include "../framework/debug.h" + +#include "gwengameprocess.h" +#include "gwengameprocessuicontroller.h" + +GwenGameProcess::GwenGameProcess(GameState *gameState, ProcessManager *processManager) + : GameProcess(gameState, processManager) +{ + STACK_TRACE; + m_gwenController = NULL; +} + +GwenGameProcess::~GwenGameProcess() +{ + STACK_TRACE; + SAFE_DELETE(m_gwenController); +} + +void GwenGameProcess::OnAdd() +{ + STACK_TRACE; + ASSERT(m_gwenController != NULL); + m_gwenController->OnAdd(); +} + +void GwenGameProcess::OnRemove() +{ + STACK_TRACE; + m_gwenController->OnRemove(); +} + +void GwenGameProcess::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + m_gwenController->OnPause(dueToOverlay); +} + +void GwenGameProcess::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + m_gwenController->OnResume(fromOverlay); +} + +void GwenGameProcess::OnLostContext() +{ + STACK_TRACE; + m_gwenController->OnLostContext(); +} + +void GwenGameProcess::OnNewContext() +{ + STACK_TRACE; + m_gwenController->OnNewContext(); +} + +void GwenGameProcess::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + m_gwenController->OnRender(renderContext); +} + +void GwenGameProcess::OnResize() +{ + STACK_TRACE; + m_gwenController->OnResize(); +} + +void GwenGameProcess::OnUpdate(float delta) +{ + STACK_TRACE; + m_gwenController->OnUpdate(delta); +} + +BOOL GwenGameProcess::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return m_gwenController->OnTransition(delta, isTransitioningOut, started); +} + +BOOL GwenGameProcess::Handle(const Event *event) +{ + STACK_TRACE; + // handle events... + + // any events we don't want to handle ourselves should be passed off to + // GwenGameProcessUIController + return m_gwenController->Handle(event); +} diff --git a/src/processes/gwengameprocess.h b/src/processes/gwengameprocess.h new file mode 100644 index 0000000..add7069 --- /dev/null +++ b/src/processes/gwengameprocess.h @@ -0,0 +1,62 @@ +#ifndef __PROCESSES_GWENGAMEPROCESS_H_INCLUDED__ +#define __PROCESSES_GWENGAMEPROCESS_H_INCLUDED__ + +#include "../framework/common.h" +#include "../framework/debug.h" +#include "gameprocess.h" + +class GwenGameProcessUIController; +class GameState; +class ProcessManager; +class RenderContext; +struct Event; + +class GwenGameProcess : public GameProcess +{ +public: + static GAMEPROCESS_TYPE GetType() + { + static GAMEPROCESS_TYPE typeName = "GwenGameProcess"; + return typeName; + } + GAMEPROCESS_TYPE GetTypeOf() const { return GetType(); } + + GwenGameProcess(GameState *gameState, ProcessManager *processManager); + virtual ~GwenGameProcess(); + + template void SetGwenHandler(); + + virtual void OnAdd(); + virtual void OnRemove(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + virtual BOOL Handle(const Event *event); + +private: + GwenGameProcessUIController *m_gwenController; + + // this is only needed so that the GwenGameProcessUIController class can + // drive the lifecycle of it's parent GwenGameProcess object, thereby + // reducing the number of cases where we'll need to create a new subclass + // of GwenGameProcess to handle specific tasks + friend class GwenGameProcessUIController; +}; + +template +void GwenGameProcess::SetGwenHandler() +{ + STACK_TRACE; + ASSERT(m_gwenController == NULL); + T *gwenController = new T(this); + m_gwenController = (GwenGameProcessUIController*)gwenController; +} + +#endif + diff --git a/src/processes/gwengameprocessuicontroller.cpp b/src/processes/gwengameprocessuicontroller.cpp new file mode 100644 index 0000000..8d7f8a0 --- /dev/null +++ b/src/processes/gwengameprocessuicontroller.cpp @@ -0,0 +1,182 @@ +#include "../framework/debug.h" + +#include "gwengameprocessuicontroller.h" +#include "gwengameprocess.h" +#include "../gameapp.h" +#include "../contexts/rendercontext.h" +#include "../framework/gwen/gwen_inputprocessor.h" +#include "../framework/gwen/gwen_spritebatchrenderer.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/viewcontext.h" +#include +#include + +GwenGameProcessUIController::GwenGameProcessUIController(GwenGameProcess *gameProcess) +{ + STACK_TRACE; + m_gameProcess = gameProcess; + m_canvas = NULL; + m_inputProcessor = NULL; + m_renderer = NULL; + m_skin = NULL; + m_alpha = 1.0f; + m_scale = 1.0f; +} + +GwenGameProcessUIController::~GwenGameProcessUIController() +{ + STACK_TRACE; + SAFE_DELETE(m_inputProcessor); + SAFE_DELETE(m_canvas); + SAFE_DELETE(m_skin); + SAFE_DELETE(m_renderer); +} + +void GwenGameProcessUIController::OnAdd() +{ + STACK_TRACE; +} + +void GwenGameProcessUIController::OnRemove() +{ + STACK_TRACE; +} + +void GwenGameProcessUIController::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + EnableGwenInput(FALSE); +} + +void GwenGameProcessUIController::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + EnableGwenInput(TRUE); +} + +void GwenGameProcessUIController::OnLostContext() +{ + STACK_TRACE; +} + +void GwenGameProcessUIController::OnNewContext() +{ + STACK_TRACE; +} + +void GwenGameProcessUIController::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + ASSERT(m_renderer != NULL); + ASSERT(m_canvas != NULL); + m_renderer->PreRender(renderContext->GetSpriteBatch()); + m_canvas->RenderCanvas(); + m_renderer->PostRender(); +} + +void GwenGameProcessUIController::OnResize() +{ + STACK_TRACE; + ResizeAndScaleCanvas(); +} + +void GwenGameProcessUIController::OnUpdate(float delta) +{ + STACK_TRACE; + ASSERT(m_canvas != NULL); + m_canvas->DoThink(); +} + +BOOL GwenGameProcessUIController::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return TRUE; +} + +BOOL GwenGameProcessUIController::Handle(const Event *event) +{ + STACK_TRACE; + return FALSE; +} + +Gwen::Controls::Canvas* GwenGameProcessUIController::InitializeGwen(const stl::string &skinFilename, const stl::string &fontFilename, uint8_t fontSize) +{ + STACK_TRACE; + ASSERT(m_renderer == NULL); + ASSERT(m_skin == NULL); + ASSERT(m_canvas == NULL); + + m_renderer = new Gwen::Renderer::SpriteBatchRenderer(GetGameProcess()->GetGameApp()->GetContentManager(), GetGameProcess()->GetGameApp()->GetGraphicsDevice()); + m_skin = new Gwen::Skin::TexturedBase(m_renderer); + + m_skin->Init(skinFilename); + m_skin->SetDefaultFont(fontFilename, (float)fontSize); + + m_canvas = new Gwen::Controls::Canvas(m_skin); + SetAlpha(1.0f); + m_scale = 1.0f; + ResizeAndScaleCanvas(); + + m_inputProcessor = new Gwen::Input::InputProcessor(GetGameProcess()->GetGameApp(), m_canvas); + + return m_canvas; +} + +void GwenGameProcessUIController::ResizeAndScaleCanvas() +{ + STACK_TRACE; + if (m_canvas != NULL) + { + // make sure that the control is using the most up-to-date scale (which + // takes into account any recent viewport resizing, etc.) + SetScale(m_scale); + + uint16_t viewportWidth = GetGameProcess()->GetGameApp()->GetGraphicsDevice()->GetViewContext()->GetViewportWidth(); + uint16_t viewportHeight = GetGameProcess()->GetGameApp()->GetGraphicsDevice()->GetViewContext()->GetViewportHeight(); + uint16_t scaledViewportWidth = (float)viewportWidth / m_canvas->Scale(); + uint16_t scaledViewportHeight = (float)viewportHeight / m_canvas->Scale(); + + m_canvas->SetBounds(0, 0, scaledViewportWidth, scaledViewportHeight); + } +} + +void GwenGameProcessUIController::EnableGwenInput(BOOL enable) +{ + STACK_TRACE; + if (m_inputProcessor != NULL) + m_inputProcessor->Enable(enable); +} + +void GwenGameProcessUIController::SetAlpha(float alpha) +{ + STACK_TRACE; + ASSERT(m_renderer != NULL); + m_alpha = alpha; + m_renderer->SetAlpha(alpha); +} + +void GwenGameProcessUIController::SetScale(float scale) +{ + STACK_TRACE; + ASSERT(m_canvas != NULL); + m_scale = scale; + + float baseScale = (float)GetGameProcess()->GetGameApp()->GetScreenScale(); + + m_canvas->SetScale(scale * baseScale); +} + +ProcessManager* GwenGameProcessUIController::GetProcessManager() const +{ + return GetGameProcess()->GetProcessManager(); +} + +GameState* GwenGameProcessUIController::GetGameState() const +{ + return GetGameProcess()->GetGameState(); +} + +void GwenGameProcessUIController::SetProcessFinished() +{ + GetGameProcess()->SetFinished(); +} diff --git a/src/processes/gwengameprocessuicontroller.h b/src/processes/gwengameprocessuicontroller.h new file mode 100644 index 0000000..3b266d5 --- /dev/null +++ b/src/processes/gwengameprocessuicontroller.h @@ -0,0 +1,114 @@ +#ifndef __STATES_GWENGAMEPROCESSUICONTROLLERHANDLER_H_INCLUDED__ +#define __STATES_GWENGAMEPROCESSUICONTROLLERHANDLER_H_INCLUDED__ + +#include "../framework/common.h" +#include "../events/event.h" +#include "gwengameprocess.h" +#include +#include + +class GameState; +class RenderContext; +class ProcessManager; + +namespace Gwen +{ + namespace Controls + { + class Canvas; + } + namespace Input + { + class InputProcessor; + } + namespace Renderer + { + class SpriteBatchRenderer; + } + namespace Skin + { + class TexturedBase; + } +} + +class GwenGameProcessUIController : public Gwen::Event::Handler +{ +public: + GwenGameProcessUIController(GwenGameProcess *gameState); + virtual ~GwenGameProcessUIController(); + + virtual void OnAdd(); + virtual void OnRemove(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + template BOOL ListenFor(); + template BOOL StopListeningFor(); + BOOL ListenFor(EVENT_TYPE type); + BOOL StopListeningFor(EVENT_TYPE type); + + virtual BOOL Handle(const Event *event); + +protected: + Gwen::Controls::Canvas* InitializeGwen(const stl::string &skinFilename, const stl::string &fontFilename, uint8_t fontSize); + void ResizeAndScaleCanvas(); + + GwenGameProcess* GetGameProcess() const { return m_gameProcess; } + Gwen::Controls::Canvas* GetCanvas() const { return m_canvas; } + + void EnableGwenInput(BOOL enable); + + float GetAlpha() const { return m_alpha; } + float GetScale() const { return m_scale; } + void SetAlpha(float alpha); + void SetScale(float scale); + + // these are for convenience and simply just call the equivalent protected + // member functions on the parent game state so that we can avoid having + // to create a new subclass of GwenGameState for each subclass of + // GwenGameStateUIController just to make this all work + + ProcessManager* GetProcessManager() const; + GameState* GetGameState() const; + void SetProcessFinished(); + +private: + GwenGameProcess *m_gameProcess; + + Gwen::Controls::Canvas *m_canvas; + Gwen::Input::InputProcessor *m_inputProcessor; + Gwen::Renderer::SpriteBatchRenderer *m_renderer; + Gwen::Skin::TexturedBase *m_skin; + float m_alpha; + float m_scale; +}; + +template +BOOL GwenGameProcessUIController::ListenFor() +{ + return m_gameProcess->ListenFor(); +} + +template +BOOL GwenGameProcessUIController::StopListeningFor() +{ + return m_gameProcess->StopListeningFor(); +} + +inline BOOL GwenGameProcessUIController::ListenFor(EVENT_TYPE type) +{ + return m_gameProcess->ListenFor(type); +} + +inline BOOL GwenGameProcessUIController::StopListeningFor(EVENT_TYPE type) +{ + return m_gameProcess->StopListeningFor(type); +} + +#endif diff --git a/src/processes/processinfo.cpp b/src/processes/processinfo.cpp new file mode 100644 index 0000000..54804c5 --- /dev/null +++ b/src/processes/processinfo.cpp @@ -0,0 +1,45 @@ +#include "../framework/debug.h" +#include "../framework/common.h" + +#include "processinfo.h" +#include "gameprocess.h" +#include + +ProcessInfo::ProcessInfo(GameProcess *process) +{ + STACK_TRACE; + ASSERT(process != NULL); + this->process = process; + name = ""; + isTransitioning = FALSE; + isTransitioningOut = FALSE; + isTransitionStarting = FALSE; + isInactive = FALSE; + isBeingRemoved = FALSE; + + SetDescriptor(); +} + +ProcessInfo::ProcessInfo(GameProcess *process, const stl::string &name) +{ + STACK_TRACE; + ASSERT(process != NULL); + this->process = process; + this->name = name; + isTransitioning = FALSE; + isTransitioningOut = FALSE; + isTransitionStarting = FALSE; + isInactive = FALSE; + isBeingRemoved = FALSE; + + SetDescriptor(); +} + +void ProcessInfo::SetDescriptor() +{ + STACK_TRACE; + m_descriptor = process->GetTypeOf(); + + if (name.length() > 0) + m_descriptor += "[" + name + "]"; +} diff --git a/src/processes/processinfo.h b/src/processes/processinfo.h new file mode 100644 index 0000000..e62beac --- /dev/null +++ b/src/processes/processinfo.h @@ -0,0 +1,31 @@ +#ifndef __PROCESSES_PROCESSINFO_H_INCLUDED__ +#define __PROCESSES_PROCESSINFO_H_INCLUDED__ + +#include "../framework/common.h" +#include + +class GameProcess; + +struct ProcessInfo +{ + ProcessInfo(GameProcess *process); + ProcessInfo(GameProcess *process, const stl::string &name); + + GameProcess *process; + stl::string name; + BOOL isTransitioning; + BOOL isTransitioningOut; + BOOL isTransitionStarting; + BOOL isInactive; + BOOL isBeingRemoved; + + const stl::string& GetDescriptor() const { return m_descriptor; } + +private: + void SetDescriptor(); + + stl::string m_descriptor; +}; + +#endif + diff --git a/src/processes/processmanager.cpp b/src/processes/processmanager.cpp new file mode 100644 index 0000000..839f57e --- /dev/null +++ b/src/processes/processmanager.cpp @@ -0,0 +1,435 @@ +#include "../framework/debug.h" +#include "../framework/log.h" + +#include "processmanager.h" +#include "gameprocess.h" +#include "processinfo.h" +#include "../states/gamestate.h" + +#define LOGCAT_PROCESSMANAGER "PROCESSMANAGER" + +ProcessManager::ProcessManager(GameState *gameState) +{ + STACK_TRACE; + m_gameState = gameState; +} + +ProcessManager::~ProcessManager() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_PROCESSMANAGER, "ProcessManager shutting down.\n"); + + while (!m_processes.empty()) + { + ProcessInfo *processInfo = m_processes.back(); + LOG_INFO(LOGCAT_PROCESSMANAGER, "Removing process %s as part of ProcessManager shutdown.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnRemove(); + SAFE_DELETE(processInfo->process); + SAFE_DELETE(processInfo); + m_processes.pop_back(); + } + + // the queue likely will not have anything in it, but just in case... + while (!m_queue.empty()) + { + ProcessInfo *processInfo = m_queue.front(); + LOG_INFO(LOGCAT_PROCESSMANAGER, "Removing queued process %s as part of ProcessManager shutdown.\n", processInfo->GetDescriptor().c_str()); + SAFE_DELETE(processInfo->process); + SAFE_DELETE(processInfo); + m_queue.pop_front(); + } +} + +void ProcessManager::Remove(const stl::string &name) +{ + STACK_TRACE; + ProcessInfoList::iterator itor = GetProcessItorFor(name); + StartTransitionOut(itor, TRUE); +} + +BOOL ProcessManager::HasProcess(const stl::string &name) const +{ + STACK_TRACE; + for (ProcessInfoList::const_iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->name.length() > 0 && name == processInfo->name) + return TRUE; + } + + return FALSE; +} + +void ProcessManager::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + if (IsEmpty()) + return; + + if (dueToOverlay) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Pausing all active processes due to state being overlayed on the parent state.\n"); + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Pausing process %s due to parent state overlay.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnPause(TRUE); + } + } + } + else + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transitioning out all active processes pending pause.\n"); + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + StartTransitionOut(i, FALSE); + } + } +} + +void ProcessManager::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + if (IsEmpty()) + return; + + if (fromOverlay) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Resuming all active processes due to overlay state being removed from overtop of parent state.\n"); + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Resuming process %s due to overlay state removal.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnResume(TRUE); + } + } + } + else + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Resuming processes.\n"); + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->isInactive && !processInfo->isBeingRemoved) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Resuming process %s.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnResume(FALSE); + + processInfo->isInactive = FALSE; + processInfo->isTransitioning = TRUE; + processInfo->isTransitioningOut = FALSE; + processInfo->isTransitionStarting = TRUE; + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transition into process %s started.\n", processInfo->GetDescriptor().c_str()); + } + } + } +} + +void ProcessManager::OnAppGainFocus() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnAppGainFocus(); + } +} + +void ProcessManager::OnAppLostFocus() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnAppLostFocus(); + } +} + +void ProcessManager::OnAppPause() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnAppPause(); + } +} + +void ProcessManager::OnAppResume() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnAppResume(); + } +} + +void ProcessManager::OnLostContext() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnLostContext(); + } +} + +void ProcessManager::OnNewContext() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnNewContext(); + } +} + +void ProcessManager::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnRender(renderContext); + } +} + +void ProcessManager::OnResize() +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnResize(); + } +} + +void ProcessManager::OnUpdate(float delta) +{ + STACK_TRACE; + CleanupInactiveProcesses(); + CheckForFinishedProcesses(); + ProcessQueue(); + UpdateTransitions(delta); + + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive) + processInfo->process->OnUpdate(delta); + } +} + +void ProcessManager::CleanupInactiveProcesses() +{ + STACK_TRACE; + if (m_processes.empty()) + return; + + ProcessInfoList::iterator i = m_processes.begin(); + while (i != m_processes.end()) + { + ProcessInfo *processInfo = *i; + if (processInfo->isInactive && processInfo->isBeingRemoved) + { + m_processes.erase(i++); + + LOG_INFO(LOGCAT_PROCESSMANAGER, "Deleting inactive process %s.\n", processInfo->GetDescriptor().c_str()); + SAFE_DELETE(processInfo->process); + SAFE_DELETE(processInfo); + } + else + ++i; + } +} + +void ProcessManager::CheckForFinishedProcesses() +{ + STACK_TRACE; + if (m_processes.empty()) + return; + + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isInactive && processInfo->process->IsFinished() && !processInfo->isTransitioning) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Process %s marked as finished.\n", processInfo->GetDescriptor().c_str()); + processInfo->isTransitioning = TRUE; + processInfo->isTransitioningOut = TRUE; + processInfo->isTransitionStarting = TRUE; + processInfo->isBeingRemoved = TRUE; + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transition out of process %s started.\n", processInfo->GetDescriptor().c_str()); + } + } +} + +void ProcessManager::ProcessQueue() +{ + STACK_TRACE; + while (!m_queue.empty()) + { + ProcessInfo *processInfo = m_queue.front(); + processInfo->isTransitioning = TRUE; + processInfo->isTransitioningOut = FALSE; + processInfo->isTransitionStarting = TRUE; + + LOG_INFO(LOGCAT_PROCESSMANAGER, "Adding process %s from queue.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnAdd(); + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transition into process %s started.\n", processInfo->GetDescriptor().c_str()); + m_processes.push_back(processInfo); + + m_queue.pop_front(); + } +} + +void ProcessManager::UpdateTransitions(float delta) +{ + STACK_TRACE; + if (m_processes.empty()) + return; + + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->isTransitioning) + { + BOOL isDone = processInfo->process->OnTransition(delta, processInfo->isTransitioningOut, processInfo->isTransitionStarting); + if (isDone) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transition %s process %s finished.\n", (processInfo->isTransitioningOut ? "out of" : "into"), processInfo->GetDescriptor().c_str()); + + // if the process was being transitioned out, then we should mark + // it as inactive, and trigger it's OnRemove event now + if (processInfo->isTransitioningOut) + { + if (processInfo->isBeingRemoved) + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Removing process %s.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnRemove(); + } + else + { + LOG_INFO(LOGCAT_PROCESSMANAGER, "Pausing process %s.\n", processInfo->GetDescriptor().c_str()); + processInfo->process->OnPause(FALSE); + } + processInfo->isInactive = TRUE; + } + + // done transitioning + processInfo->isTransitioning = FALSE; + processInfo->isTransitioningOut = FALSE; + } + processInfo->isTransitionStarting = FALSE; + } + } +} + +void ProcessManager::RemoveAll() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transitioning out all processes pending removal.\n"); + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (!processInfo->isTransitioning && !processInfo->isInactive) + StartTransitionOut(i, TRUE); + } +} + +void ProcessManager::Queue(ProcessInfo *newProcessInfo) +{ + STACK_TRACE; + ASSERT(newProcessInfo != NULL); + ASSERT(newProcessInfo->process != NULL); + + LOG_INFO(LOGCAT_PROCESSMANAGER, "Queueing process %s.\n", newProcessInfo->GetDescriptor().c_str()); + m_queue.push_back(newProcessInfo); +} + +void ProcessManager::StartTransitionOut(ProcessInfoList::iterator itor, BOOL forRemoval) +{ + STACK_TRACE; + ASSERT(itor != m_processes.end()); + ProcessInfo *processInfo = *itor; + ASSERT(processInfo->isInactive == FALSE); + ASSERT(processInfo->isTransitioning == FALSE); + processInfo->isTransitioning = TRUE; + processInfo->isTransitioningOut = TRUE; + processInfo->isTransitionStarting = TRUE; + processInfo->isBeingRemoved = forRemoval; + LOG_INFO(LOGCAT_PROCESSMANAGER, "Transition out of process %s started pending %s.\n", processInfo->GetDescriptor().c_str(), (forRemoval ? "removal" : "pause")); +} + +BOOL ProcessManager::IsTransitioning() const +{ + STACK_TRACE; + for (ProcessInfoList::const_iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + const ProcessInfo *processInfo = *i; + if (processInfo->isTransitioning) + return TRUE; + } + + return FALSE; +} + +ProcessInfoList::iterator ProcessManager::GetProcessItorFor(const stl::string &name) +{ + STACK_TRACE; + ASSERT(name.length() > 0); + if (name.length() == 0) + return m_processes.end(); + + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->name == name) + return i; + } + + return m_processes.end(); +} + +ProcessInfoList::iterator ProcessManager::GetProcessItorForFirstOf(GAMEPROCESS_TYPE processType) +{ + STACK_TRACE; + for (ProcessInfoList::iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->process->GetTypeOf() == processType) + return i; + } + + return m_processes.end(); +} + +ProcessInfo* ProcessManager::GetProcessInfoFor(const GameProcess *process) const +{ + STACK_TRACE; + ASSERT(process != NULL); + for (ProcessInfoList::const_iterator i = m_processes.begin(); i != m_processes.end(); ++i) + { + ProcessInfo *processInfo = *i; + if (processInfo->process == process) + return processInfo; + } + + return NULL; +} + diff --git a/src/processes/processmanager.h b/src/processes/processmanager.h new file mode 100644 index 0000000..70bdd09 --- /dev/null +++ b/src/processes/processmanager.h @@ -0,0 +1,87 @@ +#ifndef __PROCESSES_PROCESSMANAGER_H_INCLUDED__ +#define __PROCESSES_PROCESSMANAGER_H_INCLUDED__ + +#include "../framework/common.h" +#include "gameprocess.h" +#include "processinfo.h" +#include "../states/gamestate.h" +#include +#include + +class RenderContext; + +typedef stl::list ProcessInfoList; +typedef stl::list ProcessInfoQueue; + +class ProcessManager +{ +public: + ProcessManager(GameState *gameState); + virtual ~ProcessManager(); + + template T* Add(); + template T* Add(const stl::string &name); + void Remove(const stl::string &name); + template void RemoveFirst(); + void RemoveAll(); + + BOOL HasProcess(const stl::string &name) const; + + void OnPause(BOOL dueToOverlay); + void OnResume(BOOL fromOverlay); + void OnAppGainFocus(); + void OnAppLostFocus(); + void OnAppPause(); + void OnAppResume(); + void OnLostContext(); + void OnNewContext(); + void OnRender(RenderContext *renderContext); + void OnResize(); + void OnUpdate(float delta); + + BOOL IsTransitioning() const; + BOOL IsEmpty() const { return (m_processes.empty() && m_queue.empty()); } + BOOL IsTransitioning(const GameProcess *process) const { return GetProcessInfoFor(process)->isTransitioning; } + +private: + void Queue(ProcessInfo *newProcessInfo); + void StartTransitionOut(ProcessInfoList::iterator itor, BOOL forRemoval); + + ProcessInfoList::iterator GetProcessItorFor(const stl::string &name); + ProcessInfoList::iterator GetProcessItorForFirstOf(GAMEPROCESS_TYPE processType); + ProcessInfo* GetProcessInfoFor(const GameProcess *process) const; + + void CleanupInactiveProcesses(); + void CheckForFinishedProcesses(); + void ProcessQueue(); + void UpdateTransitions(float delta); + + GameState *m_gameState; + ProcessInfoList m_processes; + ProcessInfoQueue m_queue; +}; + +template +T* ProcessManager::Add() +{ + return Add(""); +} + +template +T* ProcessManager::Add(const stl::string &name) +{ + T *newProcess = new T(m_gameState, this); + ProcessInfo *newProcessInfo = new ProcessInfo(newProcess, name); + Queue(newProcessInfo); + return newProcess; +} + +template +void ProcessManager::RemoveFirst() +{ + ProcessInfoList::iterator itor = GetProcessItorForFirstOf(T::GetType()); + StartTransitionOut(itor, TRUE); +} + +#endif + diff --git a/src/states/gamestate.cpp b/src/states/gamestate.cpp new file mode 100644 index 0000000..4b425f5 --- /dev/null +++ b/src/states/gamestate.cpp @@ -0,0 +1,159 @@ +#include "../framework/debug.h" + +#include "gamestate.h" +#include "statemanager.h" +#include "../gameapp.h" +#include "../effects/effectmanager.h" +#include "../events/eventlistenerex.h" +#include "../processes/processmanager.h" + +GameState::GameState(GameApp *gameApp, StateManager *stateManager) + : EventListenerEx(gameApp->GetEventManager()) +{ + STACK_TRACE; + m_gameApp = gameApp; + m_stateManager = stateManager; + + m_effectManager = new EffectManager(); + ASSERT(m_effectManager != NULL); + m_processManager = new ProcessManager(this); + ASSERT(m_processManager != NULL); + + m_isFinished = FALSE; + m_returnValue = 0; + m_hasReturnValue = FALSE; +} + +GameState::~GameState() +{ + STACK_TRACE; + SAFE_DELETE(m_effectManager); + SAFE_DELETE(m_processManager); +} + +void GameState::OnPush() +{ + STACK_TRACE; +} + +void GameState::OnPop() +{ + STACK_TRACE; +} + +void GameState::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + m_processManager->OnPause(dueToOverlay); +} + +void GameState::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + m_processManager->OnResume(fromOverlay); +} + +void GameState::OnAppGainFocus() +{ + STACK_TRACE; + m_processManager->OnAppGainFocus(); + m_effectManager->OnAppGainFocus(); +} + +void GameState::OnAppLostFocus() +{ + STACK_TRACE; + m_processManager->OnAppLostFocus(); + m_effectManager->OnAppLostFocus(); +} + +void GameState::OnAppPause() +{ + STACK_TRACE; + m_processManager->OnAppPause(); + m_effectManager->OnAppPause(); +} + +void GameState::OnAppResume() +{ + STACK_TRACE; + m_processManager->OnAppResume(); + m_effectManager->OnAppResume(); +} + +void GameState::OnLostContext() +{ + STACK_TRACE; + m_processManager->OnLostContext(); + m_effectManager->OnLostContext(); +} + +void GameState::OnNewContext() +{ + STACK_TRACE; + m_processManager->OnNewContext(); + m_effectManager->OnNewContext(); +} + +void GameState::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + // switch it up and do effects before processes here so that processes + // (which would commonly be used for UI overlay elements) don't get + // overwritten by local effects (e.g. flashes, etc.) + m_effectManager->OnRenderLocal(renderContext); + m_processManager->OnRender(renderContext); +} + +void GameState::OnResize() +{ + STACK_TRACE; + m_processManager->OnResize(); + m_effectManager->OnResize(); +} + +void GameState::OnUpdate(float delta) +{ + STACK_TRACE; + m_processManager->OnUpdate(delta); + m_effectManager->OnUpdate(delta); +} + +BOOL GameState::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return TRUE; +} + +BOOL GameState::Handle(const Event *event) +{ + STACK_TRACE; + return FALSE; +} + +BOOL GameState::IsTransitioning() const +{ + STACK_TRACE; + return m_stateManager->IsTransitioning(this); +} + +BOOL GameState::IsTopState() const +{ + STACK_TRACE; + return m_stateManager->IsTop(this); +} + +void GameState::SetFinished() +{ + STACK_TRACE; + m_isFinished = TRUE; + m_returnValue = 0; + m_hasReturnValue = FALSE; +} + +void GameState::SetFinished(uint32_t returnValue) +{ + m_isFinished = TRUE; + m_returnValue = returnValue; + m_hasReturnValue = TRUE; +} diff --git a/src/states/gamestate.h b/src/states/gamestate.h new file mode 100644 index 0000000..d976eac --- /dev/null +++ b/src/states/gamestate.h @@ -0,0 +1,102 @@ +#ifndef __STATES_GAMESTATE_H_INCLUDED__ +#define __STATES_GAMESTATE_H_INCLUDED__ + +#include "../framework/common.h" +#include "../events/eventlistenerex.h" + +typedef const char* GAMESTATE_TYPE; + +class EffectManager; +class GameApp; +class ProcessManager; +class RenderContext; +class StateManager; +struct Event; + +class GameState : public EventListenerEx +{ +public: + GameState(GameApp *gameApp, StateManager *stateManager); + virtual ~GameState(); + + virtual void OnPush(); + virtual void OnPop(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnAppGainFocus(); + virtual void OnAppLostFocus(); + virtual void OnAppPause(); + virtual void OnAppResume(); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + virtual BOOL Handle(const Event *event); + + virtual GAMESTATE_TYPE GetTypeOf() const = 0; + + template BOOL Is() const; + BOOL Is(GAMESTATE_TYPE type) const; + template T* As(); + template const T* As() const; + + GameApp* GetGameApp() const { return m_gameApp; } + ProcessManager* GetProcessManager() const { return m_processManager; } + EffectManager* GetEffectManager() const { return m_effectManager; } + + BOOL IsTransitioning() const; + BOOL IsTopState() const; + BOOL IsFinished() const { return m_isFinished; } + BOOL HasReturnValue() const { return m_hasReturnValue; } + uint32_t GetReturnValue() const { return m_returnValue; } + +protected: + StateManager* GetStateManager() const { return m_stateManager; } + + void SetFinished(); + void SetFinished(uint32_t returnValue); + +private: + GameApp *m_gameApp; + StateManager *m_stateManager; + ProcessManager *m_processManager; + EffectManager *m_effectManager; + BOOL m_isFinished; + uint32_t m_returnValue; + BOOL m_hasReturnValue; +}; + +template +inline BOOL GameState::Is() const +{ + return (GetTypeOf() == T::GetType()); +} + +inline BOOL GameState::Is(GAMESTATE_TYPE type) const +{ + return (GetTypeOf() == type); +} + +template +inline T* GameState::As() +{ + if (Is()) + return (T*)this; + else + return NULL; +} + +template +inline const T* GameState::As() const +{ + if (Is()) + return (const T*)this; + else + return NULL; +} + +#endif + diff --git a/src/states/gwengamestate.cpp b/src/states/gwengamestate.cpp new file mode 100644 index 0000000..4f913c2 --- /dev/null +++ b/src/states/gwengamestate.cpp @@ -0,0 +1,95 @@ +#include "../framework/debug.h" + +#include "gwengamestate.h" +#include "gwengamestateuicontroller.h" + +GwenGameState::GwenGameState(GameApp *gameApp, StateManager *stateManager) +: GameState(gameApp, stateManager) +{ + STACK_TRACE; + m_gwenController = NULL; +} + +GwenGameState::~GwenGameState() +{ + STACK_TRACE; + SAFE_DELETE(m_gwenController); +} + +void GwenGameState::OnPush() +{ + STACK_TRACE; + ASSERT(m_gwenController != NULL); + m_gwenController->OnPush(); +} + +void GwenGameState::OnPop() +{ + STACK_TRACE; + m_gwenController->OnPop(); +} + +void GwenGameState::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + GameState::OnPause(dueToOverlay); + m_gwenController->OnPause(dueToOverlay); +} + +void GwenGameState::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + GameState::OnResume(fromOverlay); + m_gwenController->OnResume(fromOverlay); +} + +void GwenGameState::OnLostContext() +{ + STACK_TRACE; + GameState::OnLostContext(); + m_gwenController->OnLostContext(); +} + +void GwenGameState::OnNewContext() +{ + STACK_TRACE; + GameState::OnNewContext(); + m_gwenController->OnNewContext(); +} + +void GwenGameState::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + m_gwenController->OnRender(renderContext); + GameState::OnRender(renderContext); +} + +void GwenGameState::OnResize() +{ + STACK_TRACE; + GameState::OnResize(); + m_gwenController->OnResize(); +} + +void GwenGameState::OnUpdate(float delta) +{ + STACK_TRACE; + GameState::OnUpdate(delta); + m_gwenController->OnUpdate(delta); +} + +BOOL GwenGameState::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return m_gwenController->OnTransition(delta, isTransitioningOut, started); +} + +BOOL GwenGameState::Handle(const Event *event) +{ + STACK_TRACE; + // handle events... + + // any events we don't want to handle ourselves should be passed off to + // GwenGameStateUIController + return m_gwenController->Handle(event); +} diff --git a/src/states/gwengamestate.h b/src/states/gwengamestate.h new file mode 100644 index 0000000..f661629 --- /dev/null +++ b/src/states/gwengamestate.h @@ -0,0 +1,61 @@ +#ifndef __STATES_GWENGAMESTATE_H_INCLUDED__ +#define __STATES_GWENGAMESTATE_H_INCLUDED__ + +#include "../framework/common.h" +#include "../framework/debug.h" +#include "gamestate.h" + +class GameApp; +class GwenGameStateUIController; +class StateManager; +class RenderContext; +struct Event; + +class GwenGameState : public GameState +{ +public: + static GAMESTATE_TYPE GetType() + { + static GAMESTATE_TYPE typeName = "GwenGameState"; + return typeName; + } + GAMESTATE_TYPE GetTypeOf() const { return GetType(); } + + GwenGameState(GameApp *gameApp, StateManager *stateManager); + virtual ~GwenGameState(); + + template void SetGwenHandler(); + + virtual void OnPush(); + virtual void OnPop(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + virtual BOOL Handle(const Event *event); + +private: + GwenGameStateUIController *m_gwenController; + + // this is only needed so that the GwenGameStateUIController class can + // drive the lifecycle of it's parent GwenGameState object, thereby + // reducing the number of cases where we'll need to create a new subclass + // of GwenGameState to handle specific tasks + friend class GwenGameStateUIController; +}; + +template +void GwenGameState::SetGwenHandler() +{ + STACK_TRACE; + ASSERT(m_gwenController == NULL); + T *gwenController = new T(this); + m_gwenController = (GwenGameStateUIController*)gwenController; +} + +#endif diff --git a/src/states/gwengamestateuicontroller.cpp b/src/states/gwengamestateuicontroller.cpp new file mode 100644 index 0000000..cf433e6 --- /dev/null +++ b/src/states/gwengamestateuicontroller.cpp @@ -0,0 +1,183 @@ +#include "../framework/debug.h" + +#include "gwengamestateuicontroller.h" +#include "gwengamestate.h" +#include "../gameapp.h" +#include "../contexts/rendercontext.h" +#include "../framework/gwen/gwen_inputprocessor.h" +#include "../framework/gwen/gwen_spritebatchrenderer.h" +#include "../framework/graphics/graphicsdevice.h" +#include "../framework/graphics/viewcontext.h" +#include +#include + +GwenGameStateUIController::GwenGameStateUIController(GwenGameState *gameState) +{ + STACK_TRACE; + m_gameState = gameState; + m_canvas = NULL; + m_inputProcessor = NULL; + m_renderer = NULL; + m_skin = NULL; + m_alpha = 1.0f; + m_scale = 1.0f; +} + +GwenGameStateUIController::~GwenGameStateUIController() +{ + STACK_TRACE; + SAFE_DELETE(m_inputProcessor); + SAFE_DELETE(m_canvas); + SAFE_DELETE(m_skin); + SAFE_DELETE(m_renderer); +} + +void GwenGameStateUIController::OnPush() +{ + STACK_TRACE; +} + +void GwenGameStateUIController::OnPop() +{ + STACK_TRACE; +} + +void GwenGameStateUIController::OnPause(BOOL dueToOverlay) +{ + STACK_TRACE; + EnableGwenInput(FALSE); +} + +void GwenGameStateUIController::OnResume(BOOL fromOverlay) +{ + STACK_TRACE; + EnableGwenInput(TRUE); +} + +void GwenGameStateUIController::OnLostContext() +{ + STACK_TRACE; +} + +void GwenGameStateUIController::OnNewContext() +{ + STACK_TRACE; +} + +void GwenGameStateUIController::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + ASSERT(m_renderer != NULL); + ASSERT(m_canvas != NULL); + m_renderer->PreRender(renderContext->GetSpriteBatch()); + m_canvas->RenderCanvas(); + m_renderer->PostRender(); +} + +void GwenGameStateUIController::OnResize() +{ + STACK_TRACE; + ResizeAndScaleCanvas(); +} + +void GwenGameStateUIController::OnUpdate(float delta) +{ + STACK_TRACE; + ASSERT(m_canvas != NULL); + m_canvas->DoThink(); +} + +BOOL GwenGameStateUIController::OnTransition(float delta, BOOL isTransitioningOut, BOOL started) +{ + STACK_TRACE; + return TRUE; +} + +BOOL GwenGameStateUIController::Handle(const Event *event) +{ + STACK_TRACE; + return FALSE; +} + +Gwen::Controls::Canvas* GwenGameStateUIController::InitializeGwen(const stl::string &skinFilename, const stl::string &fontFilename, uint8_t fontSize) +{ + STACK_TRACE; + ASSERT(m_renderer == NULL); + ASSERT(m_skin == NULL); + ASSERT(m_canvas == NULL); + + m_renderer = new Gwen::Renderer::SpriteBatchRenderer(GetGameState()->GetGameApp()->GetContentManager(), GetGameState()->GetGameApp()->GetGraphicsDevice()); + m_skin = new Gwen::Skin::TexturedBase(m_renderer); + + m_skin->Init(skinFilename); + m_skin->SetDefaultFont(fontFilename, (float)fontSize); + + m_canvas = new Gwen::Controls::Canvas(m_skin); + SetAlpha(1.0f); + m_scale = 1.0f; + ResizeAndScaleCanvas(); + + m_inputProcessor = new Gwen::Input::InputProcessor(GetGameState()->GetGameApp(), m_canvas); + + return m_canvas; +} + +void GwenGameStateUIController::ResizeAndScaleCanvas() +{ + STACK_TRACE; + if (m_canvas != NULL) + { + // make sure that the control is using the most up-to-date scale (which + // takes into account any recent viewport resizing, etc.) + SetScale(m_scale); + + uint16_t viewportWidth = GetGameState()->GetGameApp()->GetGraphicsDevice()->GetViewContext()->GetViewportWidth(); + uint16_t viewportHeight = GetGameState()->GetGameApp()->GetGraphicsDevice()->GetViewContext()->GetViewportHeight(); + + uint16_t scaledViewportWidth = (float)viewportWidth / m_canvas->Scale(); + uint16_t scaledViewportHeight = (float)viewportHeight / m_canvas->Scale(); + + m_canvas->SetBounds(0, 0, scaledViewportWidth, scaledViewportHeight); + } +} + +void GwenGameStateUIController::EnableGwenInput(BOOL enable) +{ + STACK_TRACE; + if (m_inputProcessor != NULL) + m_inputProcessor->Enable(enable); +} + +void GwenGameStateUIController::SetAlpha(float alpha) +{ + STACK_TRACE; + ASSERT(m_renderer != NULL); + m_alpha = alpha; + m_renderer->SetAlpha(alpha); +} + +void GwenGameStateUIController::SetScale(float scale) +{ + STACK_TRACE; + ASSERT(m_canvas != NULL); + m_scale = scale; + + float baseScale = (float)GetGameState()->GetGameApp()->GetScreenScale(); + + m_canvas->SetScale(scale * baseScale); +} + +StateManager* GwenGameStateUIController::GetStateManager() const +{ + return GetGameState()->GetStateManager(); +} + +void GwenGameStateUIController::SetStateFinished() +{ + GetGameState()->SetFinished(); +} + +void GwenGameStateUIController::SetStateFinished(uint32_t returnValue) +{ + GetGameState()->SetFinished(returnValue); +} diff --git a/src/states/gwengamestateuicontroller.h b/src/states/gwengamestateuicontroller.h new file mode 100644 index 0000000..adf5209 --- /dev/null +++ b/src/states/gwengamestateuicontroller.h @@ -0,0 +1,113 @@ +#ifndef __STATES_GWENGAMESTATEUICONTROLLERHANDLER_H_INCLUDED__ +#define __STATES_GWENGAMESTATEUICONTROLLERHANDLER_H_INCLUDED__ + +#include "../framework/common.h" +#include "../events/event.h" +#include "gwengamestate.h" +#include +#include + +class RenderContext; +class StateManager; + +namespace Gwen +{ + namespace Controls + { + class Canvas; + } + namespace Input + { + class InputProcessor; + } + namespace Renderer + { + class SpriteBatchRenderer; + } + namespace Skin + { + class TexturedBase; + } +} + +class GwenGameStateUIController : public Gwen::Event::Handler +{ +public: + GwenGameStateUIController(GwenGameState *gameState); + virtual ~GwenGameStateUIController(); + + virtual void OnPush(); + virtual void OnPop(); + virtual void OnPause(BOOL dueToOverlay); + virtual void OnResume(BOOL fromOverlay); + virtual void OnLostContext(); + virtual void OnNewContext(); + virtual void OnRender(RenderContext *renderContext); + virtual void OnResize(); + virtual void OnUpdate(float delta); + virtual BOOL OnTransition(float delta, BOOL isTransitioningOut, BOOL started); + + template BOOL ListenFor(); + template BOOL StopListeningFor(); + BOOL ListenFor(EVENT_TYPE type); + BOOL StopListeningFor(EVENT_TYPE type); + + virtual BOOL Handle(const Event *event); + +protected: + Gwen::Controls::Canvas* InitializeGwen(const stl::string &skinFilename, const stl::string &fontFilename, uint8_t fontSize); + void ResizeAndScaleCanvas(); + + GwenGameState* GetGameState() const { return m_gameState; } + Gwen::Controls::Canvas* GetCanvas() const { return m_canvas; } + + void EnableGwenInput(BOOL enable); + + float GetAlpha() const { return m_alpha; } + float GetScale() const { return m_scale; } + void SetAlpha(float alpha); + void SetScale(float scale); + + // these are for convenience and simply just call the equivalent protected + // member functions on the parent game state so that we can avoid having + // to create a new subclass of GwenGameState for each subclass of + // GwenGameStateUIController just to make this all work + + StateManager* GetStateManager() const; + void SetStateFinished(); + void SetStateFinished(uint32_t returnValue); + +private: + GwenGameState *m_gameState; + + Gwen::Controls::Canvas *m_canvas; + Gwen::Input::InputProcessor *m_inputProcessor; + Gwen::Renderer::SpriteBatchRenderer *m_renderer; + Gwen::Skin::TexturedBase *m_skin; + float m_alpha; + float m_scale; +}; + +template +BOOL GwenGameStateUIController::ListenFor() +{ + return m_gameState->ListenFor(); +} + +template +BOOL GwenGameStateUIController::StopListeningFor() +{ + return m_gameState->StopListeningFor(); +} + +inline BOOL GwenGameStateUIController::ListenFor(EVENT_TYPE type) +{ + return m_gameState->ListenFor(type); +} + +inline BOOL GwenGameStateUIController::StopListeningFor(EVENT_TYPE type) +{ + return m_gameState->StopListeningFor(type); +} + +#endif diff --git a/src/states/stateinfo.cpp b/src/states/stateinfo.cpp new file mode 100644 index 0000000..237eacf --- /dev/null +++ b/src/states/stateinfo.cpp @@ -0,0 +1,49 @@ +#include "../framework/debug.h" +#include "../framework/common.h" + +#include "stateinfo.h" +#include "gamestate.h" +#include + +StateInfo::StateInfo(GameState *gameState) +{ + STACK_TRACE; + ASSERT(gameState != NULL); + this->gameState = gameState; + name = ""; + isOverlay = FALSE; + isOverlayed = FALSE; + isTransitioning = FALSE; + isTransitioningOut = FALSE; + isTransitionStarting = FALSE; + isInactive = FALSE; + isBeingPopped = FALSE; + + SetDescriptor(); +} + +StateInfo::StateInfo(GameState *gameState, const stl::string &name) +{ + STACK_TRACE; + ASSERT(gameState != NULL); + this->gameState = gameState; + this->name = name; + isOverlay = FALSE; + isOverlayed = FALSE; + isTransitioning = FALSE; + isTransitioningOut = FALSE; + isTransitionStarting = FALSE; + isInactive = FALSE; + isBeingPopped = FALSE; + + SetDescriptor(); +} + +void StateInfo::SetDescriptor() +{ + STACK_TRACE; + m_descriptor = gameState->GetTypeOf(); + + if (name.length() > 0) + m_descriptor += "[" + name + "]"; +} diff --git a/src/states/stateinfo.h b/src/states/stateinfo.h new file mode 100644 index 0000000..085761e --- /dev/null +++ b/src/states/stateinfo.h @@ -0,0 +1,33 @@ +#ifndef __STATES_STATEINFO_H_INCLUDED__ +#define __STATES_STATEINFO_H_INCLUDED__ + +#include "../framework/common.h" +#include + +class GameState; + +struct StateInfo +{ + StateInfo(GameState *gameState); + StateInfo(GameState *gameState, const stl::string &name); + + GameState *gameState; + stl::string name; + BOOL isOverlay; + BOOL isOverlayed; + BOOL isTransitioning; + BOOL isTransitioningOut; + BOOL isTransitionStarting; + BOOL isInactive; + BOOL isBeingPopped; + + const stl::string& GetDescriptor() const { return m_descriptor; } + +private: + void SetDescriptor(); + + stl::string m_descriptor; +}; + +#endif + diff --git a/src/states/statemanager.cpp b/src/states/statemanager.cpp new file mode 100644 index 0000000..61b2120 --- /dev/null +++ b/src/states/statemanager.cpp @@ -0,0 +1,590 @@ +#include "../framework/debug.h" +#include "../framework/log.h" + +#include "statemanager.h" +#include "gamestate.h" +#include "stateinfo.h" +#include "../gameapp.h" +#include "../effects/effectmanager.h" +#include "../processes/processmanager.h" + +#define LOGCAT_STATEMANAGER "STATEMANAGER" + +StateManager::StateManager(GameApp *gameApp) +{ + STACK_TRACE; + m_gameApp = gameApp; + m_stateReturnValue = 0; + m_hasStateReturnValue = FALSE; + m_pushQueueHasOverlay = FALSE; + m_swapQueueHasOverlay = FALSE; + m_lastCleanedStatesWereAllOverlays = FALSE; +} + +StateManager::~StateManager() +{ + STACK_TRACE; + LOG_INFO(LOGCAT_STATEMANAGER, "StateManager shutting down.\n"); + + while (!m_states.empty()) + { + StateInfo *stateInfo = m_states.back(); + LOG_INFO(LOGCAT_STATEMANAGER, "Popping state %s as part of StateManager shutdown.\n", stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnPop(); + SAFE_DELETE(stateInfo->gameState); + SAFE_DELETE(stateInfo); + m_states.pop_back(); + } + + // these queues likely will not have anything in them, but just in case... + while (!m_pushQueue.empty()) + { + StateInfo *stateInfo = m_pushQueue.front(); + LOG_INFO(LOGCAT_STATEMANAGER, "Deleting push-queued state %s as part of StateManager shutdown.\n", stateInfo->GetDescriptor().c_str()); + SAFE_DELETE(stateInfo->gameState); + SAFE_DELETE(stateInfo); + m_pushQueue.pop_front(); + } + while (!m_swapQueue.empty()) + { + StateInfo *stateInfo = m_swapQueue.front(); + LOG_INFO(LOGCAT_STATEMANAGER, "Deleting swap-queued state %s as part of StateManager shutdown.\n", stateInfo->GetDescriptor().c_str()); + SAFE_DELETE(stateInfo->gameState); + SAFE_DELETE(stateInfo); + m_swapQueue.pop_front(); + } +} + +void StateManager::Pop() +{ + STACK_TRACE; + ASSERT(IsTransitioning() == FALSE); + LOG_INFO(LOGCAT_STATEMANAGER, "Pop initiated for top-most state only.\n"); + StartOnlyTopStateTransitioningOut(FALSE); +} + +void StateManager::PopTopNonOverlay() +{ + STACK_TRACE; + ASSERT(IsTransitioning() == FALSE); + LOG_INFO(LOGCAT_STATEMANAGER, "Pop initiated for all top active states.\n"); + StartTopStatesTransitioningOut(FALSE); +} + +BOOL StateManager::HasState(const stl::string &name) const +{ + STACK_TRACE; + for (StateInfoList::const_iterator i = m_states.begin(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (stateInfo->name.length() > 0 && name == stateInfo->name) + return TRUE; + } + + return FALSE; +} + +void StateManager::OnAppGainFocus() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnAppGainFocus(); + } +} + +void StateManager::OnAppLostFocus() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnAppLostFocus(); + } +} + +void StateManager::OnAppPause() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnAppPause(); + } +} + +void StateManager::OnAppResume() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnAppResume(); + } +} + +void StateManager::OnLostContext() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnLostContext(); + } +} + +void StateManager::OnNewContext() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnNewContext(); + } +} + +void StateManager::OnRender(RenderContext *renderContext) +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + { + stateInfo->gameState->OnRender(renderContext); + stateInfo->gameState->GetEffectManager()->OnRenderGlobal(renderContext); + } + } +} + +void StateManager::OnResize() +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnResize(); + } +} + +void StateManager::OnUpdate(float delta) +{ + STACK_TRACE; + // clear return values (ensuring they're only accessible for 1 tick) + m_stateReturnValue = 0; + m_hasStateReturnValue = FALSE; + m_lastCleanedStatesWereAllOverlays = FALSE; + + CleanupInactiveStates(); + CheckForFinishedStates(); + ProcessQueues(); + ResumeStatesIfNeeded(); + UpdateTransitions(delta); + + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive) + stateInfo->gameState->OnUpdate(delta); + } +} + +void StateManager::ProcessQueues() +{ + STACK_TRACE; + // don't do anything if stuff is currently transitioning + if (IsTransitioning()) + return; + + ASSERT(m_pushQueue.empty() == TRUE || m_swapQueue.empty() == TRUE); + + // for each state in the queue, add it to the main list and start it + // transitioning in + while (!m_pushQueue.empty()) + { + StateInfo *stateInfo = m_pushQueue.front(); + + if (!m_states.empty()) + { + // if this new state is an overlay, and the current top state is both + // currently active and is not currently marked as being overlay-ed + // then we should pause it due to overlay + StateInfo *currentTopStateInfo = GetTop(); + if (stateInfo->isOverlay && !currentTopStateInfo->isInactive && !currentTopStateInfo->isOverlayed) + { + LOG_INFO(LOGCAT_STATEMANAGER, "Pausing %sstate %s due to overlay.\n", (currentTopStateInfo->isOverlay ? "overlay " : ""), currentTopStateInfo->GetDescriptor().c_str()); + currentTopStateInfo->gameState->OnPause(TRUE); + + // also mark the current top state as being overlay-ed + currentTopStateInfo->isOverlayed = TRUE; + } + } + + LOG_INFO(LOGCAT_STATEMANAGER, "Pushing %sstate %s from push-queue.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnPush(); + + TransitionIn(stateInfo, FALSE); + + m_states.push_back(stateInfo); + + m_pushQueue.pop_front(); + } + while (!m_swapQueue.empty()) + { + StateInfo *stateInfo = m_swapQueue.front(); + + // if this new state is an overlay, and the current top state is both + // currently active and is not currently marked as being overlay-ed + // then we should pause it due to overlay + StateInfo *currentTopStateInfo = GetTop(); + if (stateInfo->isOverlay && !currentTopStateInfo->isInactive && !currentTopStateInfo->isOverlayed) + { + LOG_INFO(LOGCAT_STATEMANAGER, "Pausing %sstate %s due to overlay.\n", (currentTopStateInfo->isOverlay ? "overlay " : ""), currentTopStateInfo->GetDescriptor().c_str()); + currentTopStateInfo->gameState->OnPause(TRUE); + + // also mark the current top state as being overlay-ed + currentTopStateInfo->isOverlayed = TRUE; + } + + LOG_INFO(LOGCAT_STATEMANAGER, "Pushing %sstate %s from swap-queue.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnPush(); + + TransitionIn(stateInfo, FALSE); + + m_states.push_back(stateInfo); + + m_swapQueue.pop_front(); + } + + m_pushQueueHasOverlay = FALSE; + m_swapQueueHasOverlay = FALSE; +} + +void StateManager::ResumeStatesIfNeeded() +{ + STACK_TRACE; + if (m_states.empty()) + return; + + // don't do anything if stuff is currently transitioning + if (IsTransitioning()) + return; + + // did we just clean up one or more overlay states? + if (m_lastCleanedStatesWereAllOverlays) + { + // then we need to resume the current top state (flagged as "from an overlay") + StateInfo *stateInfo = GetTop(); + ASSERT(stateInfo->isInactive == FALSE); + ASSERT(stateInfo->isOverlayed == TRUE); + + LOG_INFO(LOGCAT_STATEMANAGER, "Resuming %sstate %s due to overlay removal.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnResume(TRUE); + + stateInfo->isOverlayed = FALSE; + + return; + } + + // if the top state is not inactive, then we don't need to resume anything + if (!GetTop()->isInactive) + return; + + LOG_INFO(LOGCAT_STATEMANAGER, "Top-most state is inactive. Resuming top states.\n"); + + // top state is inactive, time to resume one or more states... + // find the topmost non-overlay state and take it and all overlay + // states that are above it and transition them in + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + + LOG_INFO(LOGCAT_STATEMANAGER, "Resuming %sstate %s.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnResume(FALSE); + + TransitionIn(stateInfo, TRUE); + } +} + +void StateManager::UpdateTransitions(float delta) +{ + STACK_TRACE; + if (m_states.empty()) + return; + + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (stateInfo->isTransitioning) + { + BOOL isDone = stateInfo->gameState->OnTransition(delta, stateInfo->isTransitioningOut, stateInfo->isTransitionStarting); + if (isDone) + { + LOG_INFO(LOGCAT_STATEMANAGER, "Transition %s %sstate %s finished.\n", (stateInfo->isTransitioningOut ? "out of" : "into"), (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + + // if the state was being transitioned out, then we should mark + // it as inactive, and trigger it's OnPop or OnPause event now + if (stateInfo->isTransitioningOut) + { + if (stateInfo->isBeingPopped) + { + LOG_INFO(LOGCAT_STATEMANAGER, "Popping %sstate %s.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnPop(); + + if (stateInfo->gameState->HasReturnValue()) + { + m_stateReturnValue = stateInfo->gameState->GetReturnValue(); + m_hasStateReturnValue = TRUE; + LOG_INFO(LOGCAT_STATEMANAGER, "Return value of %d retrieved from %s.\n", m_stateReturnValue, stateInfo->GetDescriptor().c_str()); + } + } + else + { + LOG_INFO(LOGCAT_STATEMANAGER, "Pausing %sstate %s.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + stateInfo->gameState->OnPause(FALSE); + } + stateInfo->isInactive = TRUE; + } + + // done transitioning + stateInfo->isTransitioning = FALSE; + stateInfo->isTransitioningOut = FALSE; + } + stateInfo->isTransitionStarting = FALSE; + } + } +} + +void StateManager::TransitionOut(StateInfo *stateInfo, BOOL forPopping) +{ + STACK_TRACE; + stateInfo->isTransitioning = TRUE; + stateInfo->isTransitioningOut = TRUE; + stateInfo->isTransitionStarting = TRUE; + stateInfo->isBeingPopped = forPopping; + LOG_INFO(LOGCAT_STATEMANAGER, "Transition out of %sstate %s started.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + + if (forPopping) + stateInfo->gameState->GetProcessManager()->RemoveAll(); + else + stateInfo->gameState->GetProcessManager()->OnPause(FALSE); +} + +void StateManager::TransitionIn(StateInfo *stateInfo, BOOL forResuming) +{ + STACK_TRACE; + stateInfo->isInactive = FALSE; + stateInfo->isTransitioning = TRUE; + stateInfo->isTransitioningOut = FALSE; + stateInfo->isTransitionStarting = TRUE; + LOG_INFO(LOGCAT_STATEMANAGER, "Transition into %sstate %s started.\n", (stateInfo->isOverlay ? "overlay " : ""), stateInfo->GetDescriptor().c_str()); + + if (forResuming) + stateInfo->gameState->GetProcessManager()->OnResume(FALSE); +} + +void StateManager::QueueForPush(StateInfo *newStateInfo) +{ + STACK_TRACE; + //ASSERT(IsTransitioning() == FALSE); + //ASSERT(m_swapQueue.empty() == TRUE); + ASSERT(newStateInfo != NULL); + ASSERT(newStateInfo->gameState != NULL); + ASSERT(m_pushQueueHasOverlay == FALSE || (m_pushQueueHasOverlay == TRUE && newStateInfo->isOverlay == TRUE)); + + LOG_INFO(LOGCAT_STATEMANAGER, "Queueing state %s for pushing.\n", newStateInfo->GetDescriptor().c_str()); + + if (!newStateInfo->isOverlay) + StartTopStatesTransitioningOut(TRUE); + + m_pushQueue.push_back(newStateInfo); + + if (newStateInfo->isOverlay) + m_pushQueueHasOverlay = TRUE; +} + +void StateManager::QueueForSwap(StateInfo *newStateInfo, BOOL swapTopNonOverlay) +{ + STACK_TRACE; + //ASSERT(IsTransitioning() == FALSE); + //ASSERT(m_pushQueue.empty() == TRUE); + ASSERT(newStateInfo != NULL); + ASSERT(newStateInfo->gameState != NULL); + ASSERT(m_swapQueueHasOverlay == FALSE || (m_swapQueueHasOverlay == TRUE && newStateInfo->isOverlay == TRUE)); + + LOG_INFO(LOGCAT_STATEMANAGER, "Queueing state %s for swapping with %s.\n", newStateInfo->GetDescriptor().c_str(), (swapTopNonOverlay ? "all top active states" : "only top-most active state.")); + + if (swapTopNonOverlay) + StartTopStatesTransitioningOut(FALSE); + else + StartOnlyTopStateTransitioningOut(FALSE); + + m_swapQueue.push_back(newStateInfo); + + if (newStateInfo->isOverlay) + m_swapQueueHasOverlay = TRUE; +} + +StateInfo* StateManager::GetTopNonOverlay() const +{ + STACK_TRACE; + StateInfoList::const_reverse_iterator itor = m_states.rbegin(); + while (itor != m_states.rend() && (*itor)->isOverlay) + ++itor; + + return (*itor); +} + +StateInfoList::iterator StateManager::GetTopNonOverlayItor() +{ + STACK_TRACE; + // TODO: probably a more efficient way to do this using reverse iterators + StateInfoList::iterator result = m_states.end(); + for (StateInfoList::iterator i = m_states.begin(); i != m_states.end(); ++i) + { + if ((*i)->isOverlay == FALSE) + result = i; + } + + return result; +} + +StateInfo* StateManager::GetStateInfoFor(const GameState *state) const +{ + STACK_TRACE; + ASSERT(state != NULL); + for (StateInfoList::const_iterator i = m_states.begin(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (stateInfo->gameState == state) + return stateInfo; + } + + return NULL; +} + +BOOL StateManager::IsTransitioning() const +{ + STACK_TRACE; + for (StateInfoList::const_iterator i = m_states.begin(); i != m_states.end(); ++i) + { + const StateInfo *stateInfo = *i; + if (stateInfo->isTransitioning) + return TRUE; + } + + return FALSE; +} + +void StateManager::StartTopStatesTransitioningOut(BOOL pausing) +{ + STACK_TRACE; + for (StateInfoList::iterator i = GetTopNonOverlayItor(); i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + // only look at active states, since inactive ones have already been + // transitioned out and will be removed on the next OnUpdate() + if (!stateInfo->isInactive) + TransitionOut(stateInfo, !pausing); + } +} + +void StateManager::StartOnlyTopStateTransitioningOut(BOOL pausing) +{ + STACK_TRACE; + StateInfo *stateInfo = GetTop(); + // if it's not active, then it's just been transitioned out and will be + // removed on the next OnUpdate() + if (!stateInfo->isInactive) + TransitionOut(stateInfo, !pausing); +} + +void StateManager::CleanupInactiveStates() +{ + STACK_TRACE; + if (m_states.empty()) + return; + + // we don't want to remove any states until everything is done transitioning. + // this is to avoid the scenario where the top non-overlay state finishes + // transitioning before one of the overlays. if we removed it, the overlays + // would then be overlayed over an inactive non-overlay (which wouldn't get + // resumed until the current active overlays were done being transitioned) + if (IsTransitioning()) + return; + + BOOL cleanedUpSomething = FALSE; + BOOL cleanedUpNonOverlay = FALSE; + + StateInfoList::iterator i = m_states.begin(); + while (i != m_states.end()) + { + StateInfo *stateInfo = *i; + if (stateInfo->isInactive && stateInfo->isBeingPopped) + { + cleanedUpSomething = TRUE; + if (!stateInfo->isOverlay) + cleanedUpNonOverlay = TRUE; + + m_states.erase(i++); + + LOG_INFO(LOGCAT_STATEMANAGER, "Deleting inactive popped state %s.\n", stateInfo->GetDescriptor().c_str()); + SAFE_DELETE(stateInfo->gameState); + SAFE_DELETE(stateInfo); + } + else + ++i; + } + + if (cleanedUpSomething && !cleanedUpNonOverlay) + m_lastCleanedStatesWereAllOverlays = TRUE; +} + +void StateManager::CheckForFinishedStates() +{ + STACK_TRACE; + if (m_states.empty()) + return; + + // don't do anything if something is currently transitioning + if (IsTransitioning()) + return; + + BOOL needToAlsoTransitionOutOverlays = FALSE; + + // check the top non-overlay state first to see if it's finished and + // should be transitioned out + StateInfo *topNonOverlayStateInfo = GetTopNonOverlay(); + if (!topNonOverlayStateInfo->isInactive && topNonOverlayStateInfo->gameState->IsFinished()) + { + LOG_INFO(LOGCAT_STATEMANAGER, "State %s marked as finished.\n", topNonOverlayStateInfo->GetDescriptor().c_str()); + TransitionOut(topNonOverlayStateInfo, TRUE); + + needToAlsoTransitionOutOverlays = TRUE; + } + + // now also check the overlay states (if there were any). we force them to + // transition out if the non-overlay state started to transition out so that + // we don't end up with overlay states without a parent non-overlay state + + // start the loop off 1 beyond the top non-overlay (which is where the + // overlays are, if any) + StateInfoList::iterator i = ++GetTopNonOverlayItor(); + for (; i != m_states.end(); ++i) + { + StateInfo *stateInfo = *i; + if (!stateInfo->isInactive && (stateInfo->gameState->IsFinished() || needToAlsoTransitionOutOverlays)) + { + LOG_INFO(LOGCAT_STATEMANAGER, "State %s marked as finished.\n", stateInfo->GetDescriptor().c_str()); + TransitionOut(stateInfo, TRUE); + } + } +} diff --git a/src/states/statemanager.h b/src/states/statemanager.h new file mode 100644 index 0000000..bfb46df --- /dev/null +++ b/src/states/statemanager.h @@ -0,0 +1,163 @@ +#ifndef __STATES_STATEMANAGER_H_INCLUDED__ +#define __STATES_STATEMANAGER_H_INCLUDED__ + +#include "../framework/common.h" +#include "gamestate.h" +#include "stateinfo.h" +#include +#include + +class GameApp; +class RenderContext; + +typedef stl::list StateInfoList; +typedef stl::list StateInfoQueue; + +class StateManager +{ +public: + StateManager(GameApp *gameApp); + virtual ~StateManager(); + + template T* Push(); + template T* Push(const stl::string &name); + template T* Overlay(); + template T* Overlay(const stl::string &name); + template T* SwapTopWith(); + template T* SwapTopWith(const stl::string &name); + template T* SwapTopNonOverlayWith(); + template T* SwapTopNonOverlayWith(const stl::string &name); + void Pop(); + void PopTopNonOverlay(); + + BOOL HasState(const stl::string &name) const; + + void OnAppGainFocus(); + void OnAppLostFocus(); + void OnAppPause(); + void OnAppResume(); + void OnLostContext(); + void OnNewContext(); + void OnRender(RenderContext *renderContext); + void OnResize(); + void OnUpdate(float delta); + + BOOL IsTransitioning() const; + BOOL IsEmpty() const { return (m_states.empty() && m_pushQueue.empty() && m_swapQueue.empty()); } + BOOL IsTop(const GameState *state) const { return GetTop()->gameState == state; } + BOOL IsTransitioning(const GameState *state) const { return GetStateInfoFor(state)->isTransitioning; } + + GameState* GetTopState() const { return GetTop()->gameState; } + GameState* GetTopNonOverlayState() const { return GetTopNonOverlay()->gameState; } + + uint32_t GetLastReturnValue() const { return m_stateReturnValue; } + BOOL HasLastReturnValue() const { return m_hasStateReturnValue; } + +private: + void QueueForPush(StateInfo *newStateInfo); + void QueueForSwap(StateInfo *newStateInfo, BOOL swapTopNonOverlay); + + StateInfo* GetTop() const; + StateInfo* GetTopNonOverlay() const; + StateInfoList::iterator GetTopNonOverlayItor(); + StateInfo* GetStateInfoFor(const GameState *state) const; + + void StartTopStatesTransitioningOut(BOOL pausing); + void StartOnlyTopStateTransitioningOut(BOOL pausing); + void CleanupInactiveStates(); + void CheckForFinishedStates(); + void ProcessQueues(); + void ResumeStatesIfNeeded(); + void UpdateTransitions(float delta); + + void TransitionOut(StateInfo *stateInfo, BOOL forPopping); + void TransitionIn(StateInfo *stateInfo, BOOL forResuming); + + GameApp *m_gameApp; + StateInfoList m_states; + StateInfoQueue m_pushQueue; + StateInfoQueue m_swapQueue; + uint32_t m_stateReturnValue; + BOOL m_hasStateReturnValue; + BOOL m_pushQueueHasOverlay; + BOOL m_swapQueueHasOverlay; + BOOL m_lastCleanedStatesWereAllOverlays; +}; + +template +T* StateManager::Push() +{ + return Push(""); +} + +template +T* StateManager::Push(const stl::string &name) +{ + T *newState = new T(m_gameApp, this); + StateInfo *newStateInfo = new StateInfo(newState, name); + QueueForPush(newStateInfo); + return newState; +}; + +template +T* StateManager::Overlay() +{ + return Overlay(""); +} + +template +T* StateManager::Overlay(const stl::string &name) +{ + T* newState = new T(m_gameApp, this); + StateInfo *newStateInfo = new StateInfo(newState, name); + newStateInfo->isOverlay = TRUE; + QueueForPush(newStateInfo); + return newState; +} + +template +T* StateManager::SwapTopWith() +{ + return SwapTopWith(""); +} + +template +T* StateManager::SwapTopWith(const stl::string &name) +{ + // figure out if the current top state is an overlay or not. use that + // same setting for the new state that is to be swapped in + StateInfo *currentTopStateInfo = GetTop(); + BOOL isOverlay = currentTopStateInfo->isOverlay; + + T* newState = new T(m_gameApp, this); + StateInfo *newStateInfo = new StateInfo(newState, name); + newStateInfo->isOverlay = isOverlay; + QueueForSwap(newStateInfo, FALSE); + return newState; +} + +template +T* StateManager::SwapTopNonOverlayWith() +{ + return SwapTopNonOverlayWith(""); +} + +template +T* StateManager::SwapTopNonOverlayWith(const stl::string &name) +{ + T *newState = new T(m_gameApp, this); + StateInfo *newStateInfo = new StateInfo(newState, name); + QueueForSwap(newStateInfo, TRUE); + return newState; +} + +inline StateInfo* StateManager::GetTop() const +{ + if (m_states.empty()) + return NULL; + else + return m_states.back(); +} + +#endif +