bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

Merge of apricot branch game engine changes into trunk, excluding GLSL.

Browse Source 
GLEW
====

Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.

* According to the GLEW website it works on Windows, Linux, Mac OS X,
  FreeBSD, Irix, and Solaris. There might still be platform specific
  issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
  regardless of the glext.h on the platform where compilation happens.

Game Engine
===========

Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.

The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.

For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.

* The game engine now also uses GLEW for extensions, replacing the
  custom opengl extensions code that was there. Removes a lot of
  #ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
  work around a specific bug and only disabled multitexturing anyway.
  It might also have caused a slowdown since it was retrieving the
  environment variable for every vertex in immediate mode (bug #13680).

* Refactored the code to allow drawing skinned meshes with vertex
  arrays too, removing some specific immediate mode drawing functions
  for this that only did extra normal calculation. Now it always splits
  vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
  required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
  attributes for vertex arrays. These were not being enabled/disabled
  correct according to the opengl spec, leading to crashes. Also tangent
  attributes used an immediate mode call for vertex arrays, which can't
  work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
  deform weights, now uses same trick as regular meshes.
This commit is contained in:
Brecht Van Lommel 2008-06-17 10:27:34 +00:00
parent c9d1924ea5
commit 272a91f754
87 changed files with 23076 additions and 3974 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
blenderplayer/CMakeLists.txt
View File

@ -108,6 +108,7 @@ IF(UNIX)
blenkernel_blc
bf_quicktime
extern_binreloc
extern_glew
)
FOREACH(SORTLIB ${BLENDER_SORTED_LIBS})

3
extern/CMakeLists.txt vendored
View File

@ -43,3 +43,6 @@ ENDIF(WITH_VERSE)
IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
SUBDIRS(binreloc)
ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
SUBDIRS(glew)

2
extern/Makefile vendored
View File

@ -30,7 +30,7 @@ include nan_definitions.mk
SOURCEDIR = extern
DIR = $(OCGDIR)/extern
DIRS = qhull/src solid
DIRS = qhull/src solid glew/src
ifeq ($(WITH_FREETYPE2), true)
DIRS += bFTGL/src

2
extern/SConscript vendored
View File

@ -2,6 +2,8 @@
Import('env')
SConscript(['glew/SConscript'])
if env['WITH_BF_GAMEENGINE']:
SConscript(['qhull/SConscript',
'solid/SConscript'])

33
extern/glew/CMakeLists.txt vendored Normal file
View File

@ -0,0 +1,33 @@
# $Id$
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# The Original Code is Copyright (C) 2006, Blender Foundation
# All rights reserved.
#
# The Original Code is: all of this file.
#
# Contributor(s): Jacques Beaurain.
#
# ***** END GPL LICENSE BLOCK *****
SET(INC include src)
SET(SRC
src/glew.c
)
BLENDERLIB(extern_glew "${SRC}" "${INC}")

18
extern/glew/README.txt vendored Normal file
View File

@ -0,0 +1,18 @@
See doc/index.html for more information.
If you downloaded the tarball from the GLEW website, you just need to:
Unix:
make
Windows:
use the project file in build/vc6/
If you wish to build GLEW from scratch (update the extension data from
the net or add your own extension information), you need a Unix
environment (including wget, perl, and GNU make). The extension data
is regenerated from the top level source directory with:
make extensions

12
extern/glew/SConscript vendored Normal file
View File

@ -0,0 +1,12 @@
#!/usr/bin/python
import sys
import os
Import('env')
sources = ['src/glew.c']
defs = ''
incs = 'include'
env.BlenderLib ( 'extern_glew', sources, Split(incs), Split(defs), libtype=['intern', 'player'], priority=[25, 50])

9797
extern/glew/include/GL/glew.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1062
extern/glew/include/GL/glxew.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

934
extern/glew/include/GL/wglew.h vendored Normal file
View File

@ -0,0 +1,934 @@
/*
** The OpenGL Extension Wrangler Library
** Copyright (C) 2002-2006, Milan Ikits <milan ikits[]ieee org>
** Copyright (C) 2002-2006, Marcelo E. Magallon <mmagallo[]debian org>
** 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.
*/
#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(APIENTRY) && !defined(__CYGWIN__)
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN 1
# endif
#include <windows.h>
#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_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_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_make_current_read ----------------------- */
#ifndef WGL_ARB_make_current_read
#define WGL_ARB_make_current_read 1
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_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_make_current_read ----------------------- */
#ifndef WGL_EXT_make_current_read
#define WGL_EXT_make_current_read 1
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_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_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_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_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_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 PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB;
WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB;
WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB;
WGLEW_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB;
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 PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV;
WGLEW_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV;
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_ARB_buffer_region;
WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string;
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_depth_float;
WGLEW_EXPORT GLboolean __WGLEW_EXT_display_color_table;
WGLEW_EXPORT GLboolean __WGLEW_EXT_extensions_string;
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_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_float_buffer;
WGLEW_EXPORT GLboolean __WGLEW_NV_render_depth_texture;
WGLEW_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle;
WGLEW_EXPORT GLboolean __WGLEW_NV_vertex_array_range;
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 (WGLEWContext* ctx, const char* name);
#define wglewInit() wglewContextInit(wglewGetContext())
#define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x)
#define WGLEW_GET_VAR(x) wglewGetContext()->x
#define WGLEW_GET_FUN(x) wglewGetContext()->x
#else /* GLEW_MX */
#define WGLEW_GET_VAR(x) 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__ */

56
extern/glew/src/Makefile vendored Normal file
View File

@ -0,0 +1,56 @@
#
# $Id$
#
# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version. The Blender
# Foundation also sells licenses for use in proprietary software under
# the Blender License. See http://www.blender.org/BL/ for information
# about this.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
# All rights reserved.
#
# The Original Code is: all of this file.
#
# Contributor(s): none yet.
#
# ***** END GPL/BL DUAL LICENSE BLOCK *****
#
#
LIBNAME = glew
DIR = $(OCGDIR)/extern/$(LIBNAME)
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += -I../include
CSRCS = glew.c
CCSRCS =
include nan_compile.mk
install: all debug
@[ -d $(NAN_GLEW) ] || mkdir -p $(NAN_GLEW)
@[ -d $(NAN_GLEW)/include/GL ] || mkdir -p $(NAN_GLEW)/include/GL
@[ -d $(NAN_GLEW)/lib ] || mkdir -p $(NAN_GLEW)/lib
@[ -d $(NAN_GLEW)/lib/debug ] || mkdir -p $(NAN_GLEW)/lib/debug
@$(NANBLENDERHOME)/intern/tools/cpifdiff.sh $(DIR)/lib$(LIBNAME).a $(NAN_GLEW)/lib/
ifeq ($(OS),darwin)
ranlib $(NAN_GLEW)/lib/lib$(LIBNAME).a
ranlib $(NAN_GLEW)/lib/lib$(LIBNAME).a
endif
@$(NANBLENDERHOME)/intern/tools/cpifdiff.sh ../include/GL/*.h $(NAN_GLEW)/include/GL

9756
extern/glew/src/glew.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
source/Makefile
View File

@ -157,6 +157,7 @@ COMLIB += $(NAN_BMFONT)/lib/$(DEBUG_DIR)libbmfont.a
COMLIB += $(NAN_PNG)/lib/libpng.a
COMLIB += $(OCGDIR)/blender/yafray/$(DEBUG_DIR)libyafrayexport.a
COMLIB += $(OCGDIR)/blender/blenlib/$(DEBUG_DIR)libblenlib.a
COMLIB += $(NAN_GLEW)/lib/libglew.a
ifeq ($(WITH_QUICKTIME), true)
COMLIB += $(OCGDIR)/blender/blenderqt/$(DEBUG_DIR)libblenderqt.a

2
source/blender/src/CMakeLists.txt
View File

@ -35,7 +35,7 @@ SET(INC
../../kernel/gen_system ../../../intern/SoundSystem ../readstreamglue
../quicktime ../../../intern/elbeem/extern
../../../intern/ghost ../../../intern/opennl/extern
../nodes
../nodes ../../../extern/glew/include
${PYTHON_INC}
${SDL_INC}
)

1
source/blender/src/Makefile
View File

@ -143,4 +143,5 @@ ifeq ($(NAN_TWEAK_MODE), true)
CPPFLAGS += -DTWEAK_MODE
endif
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)

2
source/blender/src/SConscript
View File

@ -26,7 +26,7 @@ incs += ' #/intern/bsp/extern ../radiosity/extern/include'
incs += ' #/intern/decimation/extern ../blenloader ../python'
incs += ' ../../kernel/gen_system #/intern/SoundSystem ../readstreamglue ../nodes'
incs += ' ../quicktime #/intern/elbeem/extern'
incs += ' #/intern/ghost #/intern/opennl/extern'
incs += ' #/intern/ghost #/intern/opennl/extern #/extern/glew/include'
incs += ' ' + env['BF_PYTHON_INC']

1
source/blender/src/usiblender.c
View File

@ -1038,6 +1038,7 @@ void BIF_init(void)
BIF_filelist_init_icons();
init_gl_stuff(); /* drawview.c, after homefile */
glewInit();
readBlog();
BLI_strncpy(G.lib, G.sce, FILE_MAX);
}

1
source/creator/CMakeLists.txt
View File

@ -259,6 +259,7 @@ IF(UNIX)
blender_python
bf_quicktime
extern_binreloc
extern_glew
)
FOREACH(SORTLIB ${BLENDER_SORTED_LIBS})

44
source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
View File

@ -40,9 +40,7 @@
#pragma warning (disable:4786)
#endif
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#endif
#include "GL/glew.h"
#include "KX_BlenderGL.h"
#include "KX_BlenderCanvas.h"
@ -57,10 +55,10 @@
#include "KX_PythonInit.h"
#include "KX_PyConstraintBinding.h"
#include "RAS_GLExtensionManager.h"
#include "RAS_OpenGLRasterizer.h"
#include "RAS_VAOpenGLRasterizer.h"
#include "RAS_ListRasterizer.h"
#include "RAS_GLExtensionManager.h"
#include "NG_LoopBackNetworkDeviceInterface.h"
#include "SND_DeviceManager.h"
@ -142,12 +140,12 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
// so we can safely run Python code and API calls
PyGILState_STATE gilstate = PyGILState_Ensure();
bgl::InitExtensions(1);
bgl::InitExtensions(true);
do
{
View3D *v3d= (View3D*) area->spacedata.first;
// get some preferences
SYS_SystemHandle syshandle = SYS_GetSystem();
bool properties = (SYS_GetCommandLineInt(syshandle, "show_properties", 0) != 0);
@ -156,22 +154,10 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
bool game2ipo = (SYS_GetCommandLineInt(syshandle, "game2ipo", 0) != 0);
bool displaylists = (SYS_GetCommandLineInt(syshandle, "displaylists", 0) != 0);
bool usemat = false;
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(bgl::RAS_EXT_support._ARB_multitexture && bgl::QueryVersion(1, 1)) {
usemat = (SYS_GetCommandLineInt(syshandle, "blender_material", 0) != 0);
int unitmax=0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&unitmax);
bgl::max_texture_units = MAXTEX>unitmax?unitmax:MAXTEX;
//std::cout << "using(" << bgl::max_texture_units << ") of(" << unitmax << ") texture units." << std::endl;
} else {
bgl::max_texture_units = 0;
}
}
#endif
bool usemat = false, useglslmat = false;
if(GLEW_ARB_multitexture && GLEW_VERSION_1_1)
usemat = (SYS_GetCommandLineInt(syshandle, "blender_material", 0) != 0);
// create the canvas, rasterizer and rendertools
RAS_ICanvas* canvas = new KX_BlenderCanvas(area);
@ -186,12 +172,12 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
bool lock_arrays = (displaylists && useVertexArrays);
if(displaylists){
if (useVertexArrays) {
if (useVertexArrays)
rasterizer = new RAS_ListRasterizer(canvas, true, lock_arrays);
} else {
else
rasterizer = new RAS_ListRasterizer(canvas);
}
} else if (useVertexArrays && bgl::QueryVersion(1, 1))
}
else if (useVertexArrays && GLEW_VERSION_1_1)
rasterizer = new RAS_VAOpenGLRasterizer(canvas, lock_arrays);
else
rasterizer = new RAS_OpenGLRasterizer(canvas);
@ -338,6 +324,8 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
if(usemat)
sceneconverter->SetMaterials(true);
if(useglslmat)
sceneconverter->SetGLSLMaterials(true);
KX_Scene* startscene = new KX_Scene(keyboarddevice,
mousedevice,
@ -504,7 +492,7 @@ extern "C" void StartKetsjiShellSimulation(struct ScrArea *area,
// so we can safely run Python code and API calls
PyGILState_STATE gilstate = PyGILState_Ensure();
bgl::InitExtensions(1);
bgl::InitExtensions(true);
do
{
@ -533,7 +521,7 @@ extern "C" void StartKetsjiShellSimulation(struct ScrArea *area,
if(displaylists && !useVertexArrays)
rasterizer = new RAS_ListRasterizer(canvas);
else if (useVertexArrays && bgl::QueryVersion(1, 1))
else if (useVertexArrays && GLEW_VERSION_1_1)
rasterizer = new RAS_VAOpenGLRasterizer(canvas, lock_arrays);
else
rasterizer = new RAS_OpenGLRasterizer(canvas);

1
source/gameengine/BlenderRoutines/CMakeLists.txt
View File

@ -33,6 +33,7 @@ SET(INC
../../../source/blender/blenloader
../../../extern/bullet2/src
../../../extern/solid
../../../extern/glew/include
${PYTHON_INC}
)

8
source/gameengine/BlenderRoutines/KX_BlenderCanvas.h
View File

@ -32,12 +32,8 @@
#ifdef WIN32
#include <windows.h>
#endif
#ifdef __APPLE__
# define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "GL/glew.h"
#include "RAS_ICanvas.h"
#include "RAS_Rect.h"

52
source/gameengine/BlenderRoutines/KX_BlenderGL.cpp
View File

@ -44,21 +44,9 @@
#include "BMF_Api.h"
#include "GL/glew.h"
#include "BIF_gl.h"
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else
#include <GL/glu.h>
#endif
#endif
#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
#include "RAS_OpenGLRasterizer/ARB_multitexture.h"
#include "BL_Material.h" // MAXTEX
/* Data types encoding the game world: */
@ -77,7 +65,6 @@
#include "BKE_bmfont.h"
#include "BKE_image.h"
#include "BIF_gl.h"
extern "C" {
#include "BDR_drawmesh.h"
#include "BIF_mywindow.h"
@ -88,12 +75,6 @@ extern "C" {
/* end of blender block */
#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
/* was in drawmesh.c */
void spack(unsigned int ucol)
{
@ -194,28 +175,19 @@ void DisableForText()
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
}
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
for(int i=0; i<MAXTEX; i++) {
if(bgl::RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
#ifdef GL_ARB_texture_cube_map
if(bgl::RAS_EXT_support._ARB_texture_cube_map)
if(glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
#endif
if(glIsEnabled(GL_TEXTURE_2D)) glDisable(GL_TEXTURE_2D);
}
} else {
if(glIsEnabled(GL_TEXTURE_2D)) glDisable(GL_TEXTURE_2D);
}
#else//GL_ARB_multitexture
if(glIsEnabled(GL_TEXTURE_2D)) glDisable(GL_TEXTURE_2D);
#endif
if(GLEW_ARB_multitexture)
for(int i=0; i<MAXTEX; i++)
glActiveTextureARB(GL_TEXTURE0_ARB+i);
if(GLEW_ARB_texture_cube_map)
if(glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
if(glIsEnabled(GL_TEXTURE_2D))
glDisable(GL_TEXTURE_2D);
}
void BL_print_gamedebug_line(char* text, int xco, int yco, int width, int height)
{
/* gl prepping */

13
source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
View File

@ -28,16 +28,7 @@
#include "KX_BlenderRenderTools.h"
#ifdef WIN32
// OpenGL gl.h needs 'windows.h' on windows platforms
#include <windows.h>
#endif //WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "GL/glew.h"
#include "RAS_IRenderTools.h"
#include "RAS_IRasterizer.h"
@ -317,7 +308,7 @@ void KX_BlenderRenderTools::EnableOpenGLLights()
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, true);
if (bgl::QueryExtension(bgl::_GL_EXT_separate_specular_color) || bgl::QueryVersion(1, 2))
if (GLEW_EXT_separate_specular_color || GLEW_VERSION_1_2)
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
}

3
source/gameengine/BlenderRoutines/Makefile
View File

@ -35,7 +35,6 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I$(NAN_SUMO)/include -I$(NAN_SOLID)/include
CPPFLAGS += -I$(NAN_SOLID)
CPPFLAGS += -I$(NAN_STRING)/include
@ -43,6 +42,8 @@ CPPFLAGS += -I$(NAN_MOTO)/include
CPPFLAGS += -I$(NAN_BMFONT)/include
CPPFLAGS += -I$(NAN_FUZZICS)/include
CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
# because of kernel dependency on makesdna
CPPFLAGS += -I../../blender/makesdna
CPPFLAGS += -I../../blender/include

1
source/gameengine/BlenderRoutines/SConscript
View File

@ -15,6 +15,7 @@ incs += ' #source/gameengine/SceneGraph #source/gameengine/Physics/common'
incs += ' #source/gameengine/Physics/Bullet #source/gameengine/Physics/Sumo'
incs += ' #source/gameengine/Physics/Sumo/Fuzzics/include #source/gameengine/Network/LoopBackNetwork'
incs += ' #intern/SoundSystem #source/blender/misc #source/blender/blenloader'
incs += ' #extern/glew/include'
incs += ' ' + env['BF_PYTHON_INC']
incs += ' ' + env['BF_SOLID_INC']

132
source/gameengine/BlenderRoutines/mac_compat_glext.h
View File

@ -1,132 +0,0 @@
#ifndef __mac_compat_glext_h_
#define __mac_compat_glext_h_
#ifdef __cplusplus
extern "C" {
#endif
#define APIENTRYP *
# define GL_GLEXT_LEGACY 1
# include <OpenGL/gl.h>
//#if GL_ARB_shader_objects
typedef char GLcharARB;
typedef void *GLhandleARB;
//#endif
//#if GL_ARB_vertex_buffer_object
typedef long GLintptrARB;
typedef long GLsizeiptrARB;
//#endif
// GL_ARB_multitexture
typedef void (APIENTRYP PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
//GL_ARB_shader_objects
typedef void (APIENTRYP PFNGLDELETEOBJECTARBPROC) (unsigned int obj);
typedef unsigned int (APIENTRYP PFNGLGETHANDLEARBPROC) (GLenum pname);
typedef void (APIENTRYP PFNGLDETACHOBJECTARBPROC) (unsigned int containerObj, unsigned int attachedObj);
typedef unsigned int (APIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType);
typedef void (APIENTRYP PFNGLSHADERSOURCEARBPROC) (unsigned int shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
typedef void (APIENTRYP PFNGLCOMPILESHADERARBPROC) (unsigned int shaderObj);
typedef unsigned int (APIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void);
typedef void (APIENTRYP PFNGLATTACHOBJECTARBPROC) (unsigned int containerObj, unsigned int obj);
typedef void (APIENTRYP PFNGLLINKPROGRAMARBPROC) (unsigned int programObj);
typedef void (APIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (unsigned int programObj);
typedef void (APIENTRYP PFNGLVALIDATEPROGRAMARBPROC) (unsigned int programObj);
typedef void (APIENTRYP PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0);
typedef void (APIENTRYP PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1);
typedef void (APIENTRYP PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (APIENTRYP PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (APIENTRYP PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0);
typedef void (APIENTRYP PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1);
typedef void (APIENTRYP PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2);
typedef void (APIENTRYP PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
typedef void (APIENTRYP PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint *value);
typedef void (APIENTRYP PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint *value);
typedef void (APIENTRYP PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint *value);
typedef void (APIENTRYP PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint *value);
typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERFVARBPROC) (unsigned int obj, GLenum pname, GLfloat *params);
typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERIVARBPROC) (unsigned int obj, GLenum pname, GLint *params);
typedef void (APIENTRYP PFNGLGETINFOLOGARBPROC) (unsigned int obj, GLsizei maxLength, GLsizei *length, void *infoLog);
typedef void (APIENTRYP PFNGLGETATTACHEDOBJECTSARBPROC) (unsigned int containerObj, GLsizei maxCount, GLsizei *count, unsigned int *obj);
typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONARBPROC) (unsigned int programObj, const void *name);
typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMARBPROC) (unsigned int programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
typedef void (APIENTRYP PFNGLGETUNIFORMFVARBPROC) (unsigned int programObj, GLint location, GLfloat *params);
typedef void (APIENTRYP PFNGLGETUNIFORMIVARBPROC) (unsigned int programObj, GLint location, GLint *params);
typedef void (APIENTRYP PFNGLGETSHADERSOURCEARBPROC) (unsigned int obj, GLsizei maxLength, GLsizei *length, void *source);
//GL_ARB_vertex_shader
typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONARBPROC) (unsigned int programObj, GLuint index, const GLcharARB *name);
typedef void (APIENTRYP PFNGLGETACTIVEATTRIBARBPROC) (unsigned int programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONARBPROC) (unsigned int programObj, const GLcharARB *name);
//GL_ARB_vertex_program
typedef void (APIENTRYP PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x);
typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRYP PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y);
typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRYP PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRYP PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string);
typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params);
typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params);
#define GL_FRAGMENT_SHADER 0x8B30
#define GL_COMPILE_STATUS 0x8B81
#define GL_LINK_STATUS 0x8B82
#define GL_VALIDATE_STATUS 0x8B83
#ifdef __cplusplus
}
#endif
#endif

2
source/gameengine/Converter/BL_ArmatureObject.cpp
View File

@ -144,7 +144,7 @@ void BL_ArmatureObject::GetPose(bPose **pose)
{
/* If the caller supplies a null pose, create a new one. */
/* Otherwise, copy the armature's pose channels into the caller-supplied pose */
if (!*pose) {
/* probably not to good of an idea to
duplicate everying, but it clears up

33
source/gameengine/Converter/BL_BlenderDataConversion.cpp
View File

@ -510,6 +510,7 @@ BL_Material* ConvertMaterial(
}
}
}
// above one tex the switches here
// are not used
switch(valid_index) {
@ -588,6 +589,9 @@ BL_Material* ConvertMaterial(
MT_Point2 uv[4];
MT_Point2 uv2[4];
uv[0]= uv[1]= uv[2]= uv[3]= MT_Point2(0.0f, 0.0f);
uv2[0]= uv2[1]= uv2[2]= uv2[3]= MT_Point2(0.0f, 0.0f);
if( validface ) {
material->ras_mode |= !(
@ -731,14 +735,14 @@ static MT_Vector4* BL_ComputeMeshTangentSpace(Mesh* mesh)
MT_Vector3 *tan1 = new MT_Vector3[mesh->totvert];
MT_Vector3 *tan2 = new MT_Vector3[mesh->totvert];
unsigned int v;
int v;
for (v = 0; v < mesh->totvert; v++)
{
tan1[v] = MT_Vector3(0.0, 0.0, 0.0);
tan2[v] = MT_Vector3(0.0, 0.0, 0.0);
}
for (unsigned int p = 0; p < mesh->totface; p++, mface++, tface++)
for (int p = 0; p < mesh->totface; p++, mface++, tface++)
{
MT_Vector3 v1(mesh->mvert[mface->v1].co),
v2(mesh->mvert[mface->v2].co),
@ -830,9 +834,10 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
}
}
meshobj->SetName(mesh->id.name);
meshobj->m_xyz_index_to_vertex_index_mapping.resize(mesh->totvert);
if(skinMesh)
((BL_SkinMeshObject*)meshobj)->m_mvert_to_dvert_mapping.resize(mesh->totvert);
for (int f=0;f<mesh->totface;f++,mface++)
{
@ -882,7 +887,7 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
Material* ma = 0;
bool polyvisible = true;
RAS_IPolyMaterial* polymat = NULL;
BL_Material *bl_mat;
BL_Material *bl_mat = NULL;
if(converter->GetMaterials())
{
@ -892,6 +897,7 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
ma = give_current_material(blenderobj, 1);
bl_mat = ConvertMaterial(mesh, ma, tface, mface, mmcol, lightlayer, blenderobj, layers);
bl_mat->glslmat = converter->GetGLSLMaterials();
// set the index were dealing with
bl_mat->material_index = (int)mface->mat_nr;
@ -1066,19 +1072,19 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
d3=((BL_SkinMeshObject*)meshobj)->FindOrAddDeform(vtxarray, mface->v3, &mesh->dvert[mface->v3], polymat);
if (nverts==4)
d4=((BL_SkinMeshObject*)meshobj)->FindOrAddDeform(vtxarray, mface->v4, &mesh->dvert[mface->v4], polymat);
poly->SetVertex(0,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,d1,flat, polymat));
poly->SetVertex(1,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,d2,flat, polymat));
poly->SetVertex(2,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,d3,flat, polymat));
poly->SetVertex(0,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,d1,flat,polymat,mface->v1));
poly->SetVertex(1,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,d2,flat,polymat,mface->v2));
poly->SetVertex(2,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,d3,flat,polymat,mface->v3));
if (nverts==4)
poly->SetVertex(3,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,d4, flat,polymat));
poly->SetVertex(3,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,d4,flat,polymat,mface->v4));
}
else
{
poly->SetVertex(0,meshobj->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,polymat,mface->v1));
poly->SetVertex(1,meshobj->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,polymat,mface->v2));
poly->SetVertex(2,meshobj->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,polymat,mface->v3));
poly->SetVertex(0,meshobj->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,false,polymat,mface->v1));
poly->SetVertex(1,meshobj->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,false,polymat,mface->v2));
poly->SetVertex(2,meshobj->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,false,polymat,mface->v3));
if (nverts==4)
poly->SetVertex(3,meshobj->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,polymat,mface->v4));
poly->SetVertex(3,meshobj->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,false,polymat,mface->v4));
}
meshobj->AddPolygon(poly);
if (poly->IsCollider())
@ -1116,6 +1122,9 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
layer.face++;
}
}
meshobj->m_xyz_index_to_vertex_index_mapping.clear();
if(skinMesh)
((BL_SkinMeshObject*)meshobj)->m_mvert_to_dvert_mapping.clear();
meshobj->UpdateMaterialList();
// pre calculate texture generation

160
source/gameengine/Converter/BL_MeshDeformer.cpp
View File

@ -43,27 +43,25 @@
#include "BL_SkinMeshObject.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "BLI_arithb.h"
#include "GEN_Map.h"
#include "STR_HashedString.h"
bool BL_MeshDeformer::Apply(RAS_IPolyMaterial *mat)
{
size_t i, j, index;
vecVertexArray array;
vecIndexArrays mvarray;
vecIndexArrays diarray;
RAS_TexVert *tv;
MVert *mvert;
// For each material
array = m_pMeshObject->GetVertexCache(mat);
mvarray = m_pMeshObject->GetMVertCache(mat);
diarray = m_pMeshObject->GetDIndexCache(mat);
// For each array
for (i=0; i<array.size(); i++){
// For each vertex
@ -81,9 +79,9 @@ bool BL_MeshDeformer::Apply(RAS_IPolyMaterial *mat)
BL_MeshDeformer::~BL_MeshDeformer()
{
if (m_transverts)
delete []m_transverts;
delete [] m_transverts;
if (m_transnors)
delete []m_transnors;
delete [] m_transnors;
};
/**
@ -91,65 +89,123 @@ BL_MeshDeformer::~BL_MeshDeformer()
*/
void BL_MeshDeformer::RecalcNormals()
{
int v, f;
float fnor[3], co1[3], co2[3], co3[3], co4[3];
/* We don't normalize for performance, not doing it for faces normals
* gives area-weight normals which often look better anyway, and use
* GL_NORMALIZE so we don't have to do per vertex normalization either
* since the GPU can do it faster
*
* There's a lot of indirection here to get to the data, can this work
* with less arrays/indirection? */
/* Clear all vertex normal accumulators */
for (v =0; v<m_bmesh->totvert; v++){
m_transnors[v]=MT_Point3(0,0,0);
}
/* Find the face normals */
for (f = 0; f<m_bmesh->totface; f++){
// Make new face normal based on the transverts
MFace *mf= &((MFace*)m_bmesh->mface)[f];
if (mf->v3) {
for (int vl=0; vl<3; vl++){
co1[vl]=m_transverts[mf->v1][vl];
co2[vl]=m_transverts[mf->v2][vl];
co3[vl]=m_transverts[mf->v3][vl];
if (mf->v4)
co4[vl]=m_transverts[mf->v4][vl];
vecIndexArrays indexarrays;
vecIndexArrays mvarrays;
vecIndexArrays diarrays;
vecVertexArray vertexarrays;
size_t i, j;
/* set vertex normals to zero */
for (i=0; i<(size_t)m_bmesh->totvert; i++)
m_transnors[i] = MT_Vector3(0.0f, 0.0f, 0.0f);
/* add face normals to vertices. */
for(RAS_MaterialBucket::Set::iterator mit = m_pMeshObject->GetFirstMaterial();
mit != m_pMeshObject->GetLastMaterial(); ++ mit) {
RAS_IPolyMaterial *mat = (*mit)->GetPolyMaterial();
indexarrays = m_pMeshObject->GetIndexCache(mat);
vertexarrays = m_pMeshObject->GetVertexCache(mat);
diarrays = m_pMeshObject->GetDIndexCache(mat);
mvarrays = m_pMeshObject->GetMVertCache(mat);
for (i=0; i<indexarrays.size(); i++) {
KX_VertexArray& vertexarray = (*vertexarrays[i]);
const KX_IndexArray& mvarray = (*mvarrays[i]);
const KX_IndexArray& diarray = (*diarrays[i]);
const KX_IndexArray& indexarray = (*indexarrays[i]);
int nvert = mat->UsesTriangles()? 3: 4;
for(j=0; j<indexarray.size(); j+=nvert) {
MT_Point3 mv1, mv2, mv3, mv4, fnor;
int i1 = indexarray[j];
int i2 = indexarray[j+1];
int i3 = indexarray[j+2];
RAS_TexVert& v1 = vertexarray[i1];
RAS_TexVert& v2 = vertexarray[i2];
RAS_TexVert& v3 = vertexarray[i3];
/* compute face normal */
mv1 = MT_Point3(v1.getLocalXYZ());
mv2 = MT_Point3(v2.getLocalXYZ());
mv3 = MT_Point3(v3.getLocalXYZ());
if(nvert == 4) {
int i4 = indexarray[j+3];
RAS_TexVert& v4 = vertexarray[i4];
mv4 = MT_Point3(v4.getLocalXYZ());
fnor = (((mv2-mv1).cross(mv3-mv2))+((mv4-mv3).cross(mv1-mv4))); //.safe_normalized();
}
else
fnor = ((mv2-mv1).cross(mv3-mv2)); //.safe_normalized();
/* add to vertices for smooth normals */
m_transnors[mvarray[diarray[i1]]] += fnor;
m_transnors[mvarray[diarray[i2]]] += fnor;
m_transnors[mvarray[diarray[i3]]] += fnor;
/* in case of flat - just assign, the vertices are split */
if(v1.getFlag() & TV_CALCFACENORMAL) {
v1.SetNormal(fnor);
v2.SetNormal(fnor);
v3.SetNormal(fnor);
}
if(nvert == 4) {
int i4 = indexarray[j+3];
RAS_TexVert& v4 = vertexarray[i4];
/* same as above */
m_transnors[mvarray[diarray[i4]]] += fnor;
if(v4.getFlag() & TV_CALCFACENORMAL)
v4.SetNormal(fnor);
}
}
/* FIXME: Use moto */
if (mf->v4)
CalcNormFloat4(co1, co2, co3, co4, fnor);
else
CalcNormFloat(co1, co2, co3, fnor);
/* Decide which normals are affected by this face's normal */
m_transnors[mf->v1]+=MT_Point3(fnor);
m_transnors[mf->v2]+=MT_Point3(fnor);
m_transnors[mf->v3]+=MT_Point3(fnor);
if (mf->v4)
m_transnors[mf->v4]+=MT_Point3(fnor);
}
}
for (v =0; v<m_bmesh->totvert; v++){
// float nor[3];
m_transnors[v]=m_transnors[v].safe_normalized();
// nor[0]=m_transnors[v][0];
// nor[1]=m_transnors[v][1];
// nor[2]=m_transnors[v][2];
};
/* assign smooth vertex normals */
for(RAS_MaterialBucket::Set::iterator mit = m_pMeshObject->GetFirstMaterial();
mit != m_pMeshObject->GetLastMaterial(); ++ mit) {
RAS_IPolyMaterial *mat = (*mit)->GetPolyMaterial();
vertexarrays = m_pMeshObject->GetVertexCache(mat);
diarrays = m_pMeshObject->GetDIndexCache(mat);
mvarrays = m_pMeshObject->GetMVertCache(mat);
for (i=0; i<vertexarrays.size(); i++) {
KX_VertexArray& vertexarray = (*vertexarrays[i]);
const KX_IndexArray& mvarray = (*mvarrays[i]);
const KX_IndexArray& diarray = (*diarrays[i]);
for(j=0; j<vertexarray.size(); j++)
if(!(vertexarray[j].getFlag() & TV_CALCFACENORMAL))
vertexarray[j].SetNormal(m_transnors[mvarray[diarray[j]]]); //.safe_normalized()
}
}
}
void BL_MeshDeformer::VerifyStorage()
{
/* Ensure that we have the right number of verts assigned */
if (m_tvtot!=m_bmesh->totvert+m_bmesh->totface){
if (m_tvtot!=m_bmesh->totvert+m_bmesh->totface) {
if (m_transverts)
delete []m_transverts;
delete [] m_transverts;
if (m_transnors)
delete []m_transnors;
delete [] m_transnors;
m_transnors =new MT_Point3[m_bmesh->totvert+m_bmesh->totface];
m_transverts=new float[(sizeof(*m_transverts)*m_bmesh->totvert)][3];
m_transnors=new MT_Vector3[m_bmesh->totvert];
m_tvtot = m_bmesh->totvert;
}
}

7
source/gameengine/Converter/BL_MeshDeformer.h
View File

@ -48,9 +48,9 @@ public:
BL_MeshDeformer(struct Object* obj, class BL_SkinMeshObject *meshobj ):
m_pMeshObject(meshobj),
m_bmesh((struct Mesh*)(obj->data)),
m_transverts(0),
m_transnors(0),
m_objMesh(obj),
m_transnors(NULL),
m_transverts(NULL),
m_tvtot(0)
{};
virtual ~BL_MeshDeformer();
@ -62,12 +62,11 @@ public:
protected:
class BL_SkinMeshObject* m_pMeshObject;
struct Mesh* m_bmesh;
MT_Point3* m_transnors;
//MT_Point3* m_transverts;
// this is so m_transverts doesn't need to be converted
// before deformation
float (*m_transverts)[3];
MT_Vector3* m_transnors;
struct Object* m_objMesh;
// --
int m_tvtot;

43
source/gameengine/Converter/BL_SkinDeformer.cpp
View File

@ -57,7 +57,6 @@ extern "C"{
#define __NLA_DEFNORMALS
//#undef __NLA_DEFNORMALS
BL_SkinDeformer::BL_SkinDeformer(
struct Object *bmeshobj_old, // Blender object that owns the new mesh
struct Object *bmeshobj_new, // Blender object that owns the original mesh
@ -87,25 +86,15 @@ BL_SkinDeformer::~BL_SkinDeformer()
Mat4CpyMat4(m_objMesh->obmat, m_obmat);
}
/* XXX note, this __NLA_OLDDEFORM define seems to be obsolete */
bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
{
size_t i, j, index;
vecVertexArray array;
#ifdef __NLA_OLDDEFORM
vecMVertArray mvarray;
#else
vecIndexArrays mvarray;
#endif
vecMDVertArray dvarray;
vecIndexArrays diarray;
RAS_TexVert *tv;
#ifdef __NLA_OLDDEFORM
MVert *mvert;
MDeformVert *dvert;
#endif
MT_Point3 pt;
// float co[3];
@ -115,48 +104,24 @@ bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
Update();
array = m_pMeshObject->GetVertexCache(mat);
#ifdef __NLA_OLDDEFORM
dvarray = m_pMeshObject->GetDVertCache(mat);
#endif
mvarray = m_pMeshObject->GetMVertCache(mat);
diarray = m_pMeshObject->GetDIndexCache(mat);
// For each array
for (i=0; i<array.size(); i++){
for (i=0; i<array.size(); i++) {
// For each vertex
for (j=0; j<array[i]->size(); j++){
for (j=0; j<array[i]->size(); j++) {
tv = &((*array[i])[j]);
index = ((*diarray[i])[j]);
#ifdef __NLA_OLDDEFORM
pt = tv->xyz();
mvert = ((*mvarray[i])[index]);
dvert = ((*dvarray[i])[index]);
#endif
// Copy the untransformed data from the original mvert
#ifdef __NLA_OLDDEFORM
co[0]=mvert->co[0];
co[1]=mvert->co[1];
co[2]=mvert->co[2];
// Do the deformation
/* XXX note, doesnt exist anymore */
// GB_calc_armature_deform(co, dvert);
tv->SetXYZ(co);
#else
// Set the data
tv->SetXYZ(m_transverts[((*mvarray[i])[index])]);
#ifdef __NLA_DEFNORMALS
tv->SetNormal(m_transnors[((*mvarray[i])[index])]);
#endif
#endif
}
}
return true;
}
@ -197,7 +162,9 @@ void BL_SkinDeformer::Update(void)
VECCOPY(m_transverts[v], m_bmesh->mvert[v].co);
armature_deform_verts( par_arma, m_objMesh, NULL, m_transverts, NULL, m_bmesh->totvert, ARM_DEF_VGROUP, NULL, NULL );
#ifdef __NLA_DEFNORMALS
RecalcNormals();
#endif
/* Update the current frame */
m_lastUpdate=m_armobj->GetLastFrame();

4
source/gameengine/Converter/BL_SkinDeformer.h
View File

@ -69,8 +69,8 @@ public:
m_armobj(arma),
m_lastUpdate(-1),
m_defbase(&bmeshobj->defbase),
m_releaseobject(false),
m_restoremat(false)
m_restoremat(false),
m_releaseobject(false)
{
};

24
source/gameengine/Converter/BL_SkinMeshObject.cpp
View File

@ -53,23 +53,27 @@ void BL_SkinMeshObject::AddPolygon(RAS_Polygon* poly)
RAS_MeshObject::AddPolygon(poly);
}
#ifdef __NLA_OLDDEFORM
int BL_SkinMeshObject::FindOrAddDeform(int vtxarray, struct MVert *mv, struct MDeformVert *dv, RAS_IPolyMaterial* mat)
#else
int BL_SkinMeshObject::FindOrAddDeform(unsigned int vtxarray, unsigned int mv, struct MDeformVert *dv, RAS_IPolyMaterial* mat)
#endif
{
BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
int numvert = ao->m_MvertArrayCache1[vtxarray]->size();
/* Check to see if this has already been pushed */
for (unsigned int i=0; i<ao->m_MvertArrayCache1[vtxarray]->size(); i++){
if (mv == (*ao->m_MvertArrayCache1[vtxarray])[i])
return i;
for (vector<BL_MDVertMap>::iterator it = m_mvert_to_dvert_mapping[mv].begin();
it != m_mvert_to_dvert_mapping[mv].end();
it++)
{
if(it->mat == mat)
return it->index;
}
ao->m_MvertArrayCache1[vtxarray]->push_back(mv);
ao->m_DvertArrayCache1[vtxarray]->push_back(dv);
BL_MDVertMap mdmap;
mdmap.mat = mat;
mdmap.index = numvert;
m_mvert_to_dvert_mapping[mv].push_back(mdmap);
return numvert;
};
@ -105,11 +109,7 @@ int BL_SkinMeshObject::FindVertexArray(int numverts,RAS_IPolyMaterial* polymat)
KX_IndexArray *ia = new KX_IndexArray();
ao->m_IndexArrayCache1.push_back(ia);
#ifdef __NLA_OLDDEFORM
BL_MVertArray *bva = new BL_MVertArray();
#else
KX_IndexArray *bva = new KX_IndexArray();
#endif
ao->m_MvertArrayCache1.push_back(bva);
BL_DeformVertArray *dva = new BL_DeformVertArray();

43
source/gameengine/Converter/BL_SkinMeshObject.h
View File

@ -106,6 +106,9 @@ class BL_SkinMeshObject : public RAS_MeshObject
protected:
public:
struct BL_MDVertMap { RAS_IPolyMaterial *mat; int index; };
vector<vector<BL_MDVertMap> > m_mvert_to_dvert_mapping;
void Bucketize(double* oglmatrix,void* clientobj,bool useObjectColor,const MT_Vector4& rgbavec);
// void Bucketize(double* oglmatrix,void* clientobj,bool useObjectColor,const MT_Vector4& rgbavec,class RAS_BucketManager* bucketmgr);
@ -139,37 +142,17 @@ public:
const MT_Point2& uv2,
const MT_Vector4& tangent,
const unsigned int rgbacolor,
const MT_Vector3& normal, int defnr, bool flat, RAS_IPolyMaterial* mat)
const MT_Vector3& normal, int defnr, bool flat, RAS_IPolyMaterial* mat, int origindex)
{
RAS_TexVert tempvert(xyz,uv,uv2, tangent,rgbacolor,normal,flat ? TV_CALCFACENORMAL : 0);
// KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
int numverts = ao->m_VertexArrayCache1[vtxarray]->size();//m_VertexArrayCount[vtxarray];
int index=-1;
for (int i=0;i<numverts;i++)
{
const RAS_TexVert& vtx = (*ao->m_VertexArrayCache1[vtxarray])[i];
if (tempvert.closeTo(&vtx))
{
index = i;
break;
}
}
if (index >= 0)
return index;
// no vertex found, add one
ao->m_VertexArrayCache1[vtxarray]->push_back(tempvert);
ao->m_DIndexArrayCache1[vtxarray]->push_back(defnr);
return numverts;
BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);
int numverts = ao->m_VertexArrayCache1[vtxarray]->size();
int index = RAS_MeshObject::FindOrAddVertex(vtxarray, xyz, uv, uv2, tangent, rgbacolor, normal, flat, mat, origindex);
/* this means a new vertex was added, so we add the defnr too */
if(index == numverts)
ao->m_DIndexArrayCache1[vtxarray]->push_back(defnr);
return index;
}
};

14
source/gameengine/Converter/KX_BlenderSceneConverter.cpp
View File

@ -100,7 +100,8 @@ KX_BlenderSceneConverter::KX_BlenderSceneConverter(
m_sipo(sipo),
m_ketsjiEngine(engine),
m_alwaysUseExpandFraming(false),
m_usemat(false)
m_usemat(false),
m_useglslmat(false)
{
m_newfilename = "";
}
@ -449,6 +450,13 @@ void KX_BlenderSceneConverter::RemoveScene(KX_Scene *scene)
void KX_BlenderSceneConverter::SetMaterials(bool val)
{
m_usemat = val;
m_useglslmat = false;
}
void KX_BlenderSceneConverter::SetGLSLMaterials(bool val)
{
m_usemat = val;
m_useglslmat = val;
}
bool KX_BlenderSceneConverter::GetMaterials()
@ -456,6 +464,10 @@ bool KX_BlenderSceneConverter::GetMaterials()
return m_usemat;
}
bool KX_BlenderSceneConverter::GetGLSLMaterials()
{
return m_useglslmat;
}
void KX_BlenderSceneConverter::RegisterBlenderMaterial(BL_Material *mat)
{

5
source/gameengine/Converter/KX_BlenderSceneConverter.h
View File

@ -75,6 +75,7 @@ class KX_BlenderSceneConverter : public KX_ISceneConverter
class KX_Scene* m_currentScene; // Scene being converted
bool m_alwaysUseExpandFraming;
bool m_usemat;
bool m_useglslmat;
void localDel_ipoCurve ( IpoCurve * icu ,struct SpaceIpo* sipo);
// struct Ipo* findIpoForName(char* objName);
@ -146,6 +147,10 @@ public:
virtual void SetMaterials(bool val);
virtual bool GetMaterials();
// use blender glsl materials
virtual void SetGLSLMaterials(bool val);
virtual bool GetGLSLMaterials();
};
#endif //__KX_BLENDERSCENECONVERTER_H

1
source/gameengine/GamePlayer/common/CMakeLists.txt
View File

@ -69,6 +69,7 @@ SET(INC
../../../../source/gameengine/GamePlayer/ghost
../../../../source/blender/misc
../../../../source/blender/blenloader
../../../../extern/glew/include
${PYTHON_INC}
${SOLID_INC}
${PNG_INC}

18
source/gameengine/GamePlayer/common/GPC_Canvas.h
View File

@ -33,18 +33,12 @@
#include "RAS_ICanvas.h"
#include "RAS_Rect.h"
#if defined(WIN32) || defined(__APPLE__)
#ifdef WIN32
#pragma warning (disable:4786) // suppress stl-MSVC debug info warning
#include <windows.h>
#include <GL/gl.h>
#else // WIN32
// __APPLE__ is defined
#include <AGL/gl.h>
#endif // WIN32
#else //defined(WIN32) || defined(__APPLE__)
#include <GL/gl.h>
#endif //defined(WIN32) || defined(__APPLE__)
#ifdef WIN32
#pragma warning (disable:4786) // suppress stl-MSVC debug info warning
#include <windows.h>
#endif // WIN32
#include "GL/glew.h"
#include <map>

19
source/gameengine/GamePlayer/common/GPC_PolygonMaterial.cpp
View File

@ -31,23 +31,7 @@
#include <config.h>
#endif
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else
#include <GL/glu.h>
#endif
#endif
#include "GL/glew.h"
#include "GPC_PolygonMaterial.h"
#include "MT_Vector3.h"
@ -88,7 +72,6 @@ static int fDoMipMap = 1;
static int fLinearMipMap=1;
static int fAlphamode= -1;
using namespace bgl;
/* (n&(n-1)) zeros the least significant bit of n */
static int is_pow2(int num) {
return ((num)&(num-1))==0;

14
source/gameengine/GamePlayer/common/GPC_RenderTools.cpp
View File

@ -34,12 +34,8 @@
#include <windows.h>
#endif
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "GL/glew.h"
#include <iostream>
#include "GPC_RenderTools.h"
@ -137,10 +133,6 @@ int GPC_RenderTools::ProcessLighting(int layer)
{
if (m_clientobject)
{
if (layer == RAS_LIGHT_OBJECT_LAYER)
{
layer = static_cast<KX_GameObject*>(m_clientobject)->GetLayer();
}
if (applyLights(layer))
{
EnableOpenGLLights();
@ -160,7 +152,7 @@ void GPC_RenderTools::EnableOpenGLLights()
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_DIFFUSE);
if (bgl::QueryExtension(bgl::_GL_EXT_separate_specular_color) || bgl::QueryVersion(1, 2))
if (GLEW_EXT_separate_specular_color || GLEW_VERSION_1_2)
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
}

15
source/gameengine/GamePlayer/common/GPC_RenderTools.h
View File

@ -30,18 +30,11 @@
#ifndef __GPC_RENDERTOOLS_H
#define __GPC_RENDERTOOLS_H
#if defined(WIN32) || defined(__APPLE__)
#ifdef WIN32
#include <windows.h>
#include <GL/gl.h>
#else // WIN32
// __APPLE__ is defined
#include <AGL/gl.h>
#endif // WIN32
#else //defined(WIN32) || defined(__APPLE__)
#include <GL/gl.h>
#endif //defined(WIN32) || defined(__APPLE__)
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#include "GL/glew.h"
#include "RAS_IRenderTools.h"

1
source/gameengine/GamePlayer/common/Makefile
View File

@ -35,6 +35,7 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I../../../blender/blenkernel

3
source/gameengine/GamePlayer/common/SConscript
View File

@ -45,7 +45,8 @@ incs = ['.',
'#source/gameengine/Network/LoopBackNetwork',
'#source/gameengine/GamePlayer/ghost',
'#source/blender/misc',
'#source/blender/blenloader']
'#source/blender/blenloader',
'#extern/glew/include']
#This is all plugin stuff!
#if sys.platform=='win32':

1
source/gameengine/GamePlayer/ghost/CMakeLists.txt
View File

@ -65,6 +65,7 @@ SET(INC
../../../../source/blender/misc
../../../../source/blender/blenloader
../../../../extern/solid
../../../../extern/glew/include
${PYTHON_INC}
)

43
source/gameengine/GamePlayer/ghost/GPG_Application.cpp
View File

@ -37,18 +37,7 @@
#include <windows.h>
#endif
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else
#include <GL/glu.h>
#endif
#endif
#include "GL/glew.h"
#include "GPG_Application.h"
@ -134,7 +123,8 @@ GPG_Application::GPG_Application(GHOST_ISystem* system, struct Main* maggie, STR
m_sceneconverter(0),
m_networkdevice(0),
m_audiodevice(0),
m_blendermat(0)
m_blendermat(0),
m_blenderglslmat(0)
{
fSystem = system;
}
@ -487,7 +477,8 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
{
if (!m_engineInitialized)
{
bgl::InitExtensions(1);
glewInit();
bgl::InitExtensions(true);
// get and set the preferences
SYS_SystemHandle syshandle = SYS_GetSystem();
@ -508,26 +499,10 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
bool useVertexArrays = SYS_GetCommandLineInt(syshandle,"vertexarrays",1) != 0;
bool useLists = (SYS_GetCommandLineInt(syshandle, "displaylists", G.fileflags & G_FILE_DIAPLAY_LISTS) != 0);
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(GLEW_ARB_multitexture && GLEW_VERSION_1_1) {
int gameflag =(G.fileflags & G_FILE_GAME_MAT);
if(bgl::RAS_EXT_support._ARB_multitexture && bgl::QueryVersion(1, 1)) {
m_blendermat = (SYS_GetCommandLineInt(syshandle, "blender_material", gameflag) != 0);
int unitmax=0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&unitmax);
bgl::max_texture_units = MAXTEX>unitmax?unitmax:MAXTEX;
//std::cout << "using(" << bgl::max_texture_units << ") of(" << unitmax << ") texture units." << std::endl;
} else {
bgl::max_texture_units = 0;
}
} else {
m_blendermat=0;
m_blendermat = (SYS_GetCommandLineInt(syshandle, "blender_material", gameflag) != 0);
}
#else
m_blendermat=0;
#endif//GL_ARB_multitexture
// ----------------------------------
// create the canvas, rasterizer and rendertools
m_canvas = new GPG_Canvas(window);
@ -545,7 +520,7 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
} else {
m_rasterizer = new RAS_ListRasterizer(m_canvas);
}
else if (useVertexArrays && bgl::QueryVersion(1, 1))
else if (useVertexArrays && GLEW_VERSION_1_1)
m_rasterizer = new RAS_VAOpenGLRasterizer(m_canvas);
else
m_rasterizer = new RAS_OpenGLRasterizer(m_canvas);
@ -655,6 +630,8 @@ bool GPG_Application::startEngine(void)
// sceneconverter->SetAlwaysUseExpandFraming(true);
if(m_blendermat)
m_sceneconverter->SetMaterials(true);
if(m_blenderglslmat)
m_sceneconverter->SetGLSLMaterials(true);
KX_Scene* startscene = new KX_Scene(m_keyboard,
m_mouse,

1
source/gameengine/GamePlayer/ghost/GPG_Application.h
View File

@ -141,6 +141,7 @@ protected:
SND_IAudioDevice* m_audiodevice;
bool m_blendermat;
bool m_blenderglslmat;
};

1
source/gameengine/GamePlayer/ghost/Makefile
View File

@ -36,6 +36,7 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
# OpenGL header files
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I$(NAN_STRING)/include
CPPFLAGS += -I$(NAN_BMFONT)/include

3
source/gameengine/GamePlayer/ghost/SConscript
View File

@ -39,7 +39,8 @@ incs = ['.',
'#source/gameengine/Network/LoopBackNetwork',
'#source/gameengine/GamePlayer/common',
'#source/blender/misc',
'#source/blender/blenloader']
'#source/blender/blenloader',
'#extern/glew/include']
incs += Split(env['BF_PYTHON_INC'])
incs += Split(env['BF_SOLID_INC'])

149
source/gameengine/Ketsji/BL_BlenderShader.cpp Normal file
View File

@ -0,0 +1,149 @@
#include "DNA_customdata_types.h"
#include "BL_BlenderShader.h"
#if 0
#include "GPU_extensions.h"
#include "GPU_material.h"
#endif
#include "RAS_MeshObject.h"
#include "RAS_IRasterizer.h"
const bool BL_BlenderShader::Ok()const
{
#if 0
return (mGPUMat != 0);
#endif
return false;
}
BL_BlenderShader::BL_BlenderShader(struct Material *ma)
:
#if 0
mGPUMat(0),
#endif
mBound(false)
{
#if 0
if(ma)
mGPUMat = GPU_material_from_blender(ma, GPU_PROFILE_DERIVEDMESH);
#endif
}
BL_BlenderShader::~BL_BlenderShader()
{
#if 0
if(mGPUMat) {
GPU_material_unbind(mGPUMat);
mGPUMat = 0;
}
#endif
}
void BL_BlenderShader::ApplyShader()
{
}
void BL_BlenderShader::SetProg(bool enable)
{
#if 0
if(mGPUMat) {
if(enable) {
GPU_material_bind(mGPUMat);
mBound = true;
}
else {
GPU_material_unbind(mGPUMat);
mBound = false;
}
}
#endif
}
int BL_BlenderShader::GetAttribNum()
{
#if 0
GPUVertexAttribs attribs;
int i, enabled = 0;
if(!mGPUMat)
return enabled;
GPU_material_vertex_attributes(mGPUMat, &attribs);
for(i = 0; i < attribs.totlayer; i++)
if(attribs.layer[i].glindex+1 > enabled)
enabled= attribs.layer[i].glindex+1;
if(enabled > BL_MAX_ATTRIB)
enabled = BL_MAX_ATTRIB;
return enabled;
#endif
return 0;
}
void BL_BlenderShader::SetTexCoords(RAS_IRasterizer* ras)
{
#if 0
GPUVertexAttribs attribs;
int i, attrib_num;
if(!mGPUMat)
return;
if(ras->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
GPU_material_vertex_attributes(mGPUMat, &attribs);
attrib_num = GetAttribNum();
ras->SetTexCoordNum(0);
ras->SetAttribNum(attrib_num);
for(i=0; i<attrib_num; i++)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
for(i = 0; i < attribs.totlayer; i++) {
if(attribs.layer[i].glindex > attrib_num)
continue;
if(attribs.layer[i].type == CD_MTFACE)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_UV1, attribs.layer[i].glindex);
else if(attribs.layer[i].type == CD_TANGENT)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT, attribs.layer[i].glindex);
else if(attribs.layer[i].type == CD_ORCO)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_ORCO, attribs.layer[i].glindex);
else if(attribs.layer[i].type == CD_NORMAL)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_NORM, attribs.layer[i].glindex);
}
ras->EnableTextures(true);
}
else
ras->EnableTextures(false);
#endif
}
void BL_BlenderShader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
{
#if 0
float obmat[4][4], viewmat[4][4];
if(!mGPUMat || !mBound)
return;
MT_Matrix4x4 model;
model.setValue(ms.m_OpenGLMatrix);
MT_Matrix4x4 view;
rasty->GetViewMatrix(view);
model.getValue((float*)obmat);
view.getValue((float*)viewmat);
GPU_material_bind_uniforms(mGPUMat, obmat, viewmat);
#endif
}
// eof

44
source/gameengine/Ketsji/BL_BlenderShader.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef __BL_GPUSHADER_H__
#define __BL_GPUSHADER_H__
#if 0
#include "GPU_material.h"
#endif
#include "MT_Matrix4x4.h"
#include "MT_Matrix3x3.h"
#include "MT_Tuple2.h"
#include "MT_Tuple3.h"
#include "MT_Tuple4.h"
struct Material;
#define BL_MAX_ATTRIB 16
/**
* BL_BlenderShader
* Blender GPU shader material
*/
class BL_BlenderShader
{
private:
#if 0
GPUMaterial *mGPUMat;
#endif
bool mBound;
public:
BL_BlenderShader(struct Material *ma);
virtual ~BL_BlenderShader();
const bool Ok()const;
void SetProg(bool enable);
void ApplyShader();
void SetTexCoords(class RAS_IRasterizer* ras);
int GetAttribNum();
void Update(const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty);
};
#endif//__BL_GPUSHADER_H__

1
source/gameengine/Ketsji/BL_Material.cpp
View File

@ -34,6 +34,7 @@ BL_Material::BL_Material()
rgb[3] = 0;
IdMode = 0;
ras_mode = 0;
glslmat = 0;
tile = 0;
matname = "NoMaterial";
matcolor[0] = 0.5f;

3
source/gameengine/Ketsji/BL_Material.h
View File

@ -20,7 +20,7 @@ struct EnvMap;
although the more you add the slower the search time will be.
we will go for three, which should be enough
*/
#define MAXTEX 3//match in RAS_TexVert & RAS_OpenGLRasterizer
#define MAXTEX 3 //match in RAS_TexVert & RAS_OpenGLRasterizer
// different mapping modes
class BL_Mapping
@ -47,6 +47,7 @@ public:
int IdMode;
unsigned int ras_mode;
bool glslmat;
STR_String texname[MAXTEX];
unsigned int flag[MAXTEX];

306
source/gameengine/Ketsji/BL_Shader.cpp
View File

@ -1,21 +1,5 @@
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
/* #if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else
*/
#include <GL/glu.h>
/* #endif */
#endif
#include "GL/glew.h"
#include <iostream>
#include "BL_Shader.h"
@ -31,7 +15,6 @@
#include "RAS_MeshObject.h"
#include "RAS_IRasterizer.h"
//using namespace bgl;
#define spit(x) std::cout << x << std::endl;
#define SORT_UNIFORMS 1
@ -46,7 +29,7 @@ BL_Uniform::BL_Uniform(int data_size)
mDataLen(data_size)
{
#ifdef SORT_UNIFORMS
MT_assert(mDataLen <= UNIFORM_MAX_LEN);
MT_assert((int)mDataLen <= UNIFORM_MAX_LEN);
mData = (void*)MEM_mallocN(mDataLen, "shader-uniform-alloc");
#endif
}
@ -63,7 +46,6 @@ BL_Uniform::~BL_Uniform()
void BL_Uniform::Apply(class BL_Shader *shader)
{
#ifdef GL_ARB_shader_objects
#ifdef SORT_UNIFORMS
MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData);
@ -74,48 +56,47 @@ void BL_Uniform::Apply(class BL_Shader *shader)
{
case UNI_FLOAT: {
float *f = (float*)mData;
bgl::blUniform1fARB(mLoc,(GLfloat)*f);
glUniform1fARB(mLoc,(GLfloat)*f);
}break;
case UNI_INT: {
int *f = (int*)mData;
bgl::blUniform1iARB(mLoc, (GLint)*f);
glUniform1iARB(mLoc, (GLint)*f);
}break;
case UNI_FLOAT2: {
float *f = (float*)mData;
bgl::blUniform2fvARB(mLoc,1, (GLfloat*)f);
glUniform2fvARB(mLoc,1, (GLfloat*)f);
}break;
case UNI_FLOAT3: {
float *f = (float*)mData;
bgl::blUniform3fvARB(mLoc,1,(GLfloat*)f);
glUniform3fvARB(mLoc,1,(GLfloat*)f);
}break;
case UNI_FLOAT4: {
float *f = (float*)mData;
bgl::blUniform4fvARB(mLoc,1,(GLfloat*)f);
glUniform4fvARB(mLoc,1,(GLfloat*)f);
}break;
case UNI_INT2: {
int *f = (int*)mData;
bgl::blUniform2ivARB(mLoc,1,(GLint*)f);
glUniform2ivARB(mLoc,1,(GLint*)f);
}break;
case UNI_INT3: {
int *f = (int*)mData;
bgl::blUniform3ivARB(mLoc,1,(GLint*)f);
glUniform3ivARB(mLoc,1,(GLint*)f);
}break;
case UNI_INT4: {
int *f = (int*)mData;
bgl::blUniform4ivARB(mLoc,1,(GLint*)f);
glUniform4ivARB(mLoc,1,(GLint*)f);
}break;
case UNI_MAT4: {
float *f = (float*)mData;
bgl::blUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
}break;
case UNI_MAT3: {
float *f = (float*)mData;
bgl::blUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
}break;
}
mDirty = false;
#endif
#endif
}
void BL_Uniform::SetData(int location, int type,bool transpose)
@ -144,17 +125,14 @@ BL_Shader::BL_Shader(PyTypeObject *T)
mError(0),
mDirty(true)
{
// if !RAS_EXT_support._ARB_shader_objects this class will not be used
// if !GLEW_ARB_shader_objects this class will not be used
//for (int i=0; i<MAXTEX; i++) {
// mSampler[i] = BL_Sampler();
//}
}
using namespace bgl;
BL_Shader::~BL_Shader()
{
#ifdef GL_ARB_shader_objects
//for (int i=0; i<MAXTEX; i++){
// if(mSampler[i].mOwn) {
// if(mSampler[i].mTexture)
@ -164,14 +142,13 @@ BL_Shader::~BL_Shader()
ClearUniforms();
if( mShader ) {
bgl::blDeleteObjectARB(mShader);
glDeleteObjectARB(mShader);
mShader = 0;
}
vertProg = 0;
fragProg = 0;
mOk = 0;
bgl::blUseProgramObjectARB(0);
#endif//GL_ARB_shader_objects
glUseProgramObjectARB(0);
}
void BL_Shader::ClearUniforms()
@ -266,8 +243,6 @@ void BL_Shader::UnloadShader()
bool BL_Shader::LinkProgram()
{
#ifdef GL_ARB_shader_objects
int vertlen = 0, fraglen=0, proglen=0;
int vertstatus=0, fragstatus=0, progstatus=0;
unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
@ -281,25 +256,25 @@ bool BL_Shader::LinkProgram()
spit("Invalid GLSL sources");
return false;
}
if( !RAS_EXT_support._ARB_fragment_shader) {
if( !GLEW_ARB_fragment_shader) {
spit("Fragment shaders not supported");
return false;
}
if( !RAS_EXT_support._ARB_vertex_shader) {
if( !GLEW_ARB_vertex_shader) {
spit("Vertex shaders not supported");
return false;
}
// -- vertex shader ------------------
tmpVert = bgl::blCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
bgl::blShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
bgl::blCompileShaderARB(tmpVert);
bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
glCompileShaderARB(tmpVert);
glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
// print info if any
if( vertlen > 0 && vertlen < MAX_LOG_LEN){
logInf = (char*)MEM_mallocN(vertlen, "vert-log");
bgl::blGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
if(char_len >0) {
spit("---- Vertex Shader Error ----");
spit(logInf);
@ -308,20 +283,20 @@ bool BL_Shader::LinkProgram()
logInf=0;
}
// check for compile errors
bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
if(!vertstatus) {
spit("---- Vertex shader failed to compile ----");
goto programError;
}
// -- fragment shader ----------------
tmpFrag = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
bgl::blShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
bgl::blCompileShaderARB(tmpFrag);
bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
glCompileShaderARB(tmpFrag);
glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
if(fraglen >0 && fraglen < MAX_LOG_LEN){
logInf = (char*)MEM_mallocN(fraglen, "frag-log");
bgl::blGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
if(char_len >0) {
spit("---- Fragment Shader Error ----");
spit(logInf);
@ -330,7 +305,7 @@ bool BL_Shader::LinkProgram()
logInf=0;
}
bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
if(!fragstatus){
spit("---- Fragment shader failed to compile ----");
goto programError;
@ -339,17 +314,17 @@ bool BL_Shader::LinkProgram()
// -- program ------------------------
// set compiled vert/frag shader & link
tmpProg = bgl::blCreateProgramObjectARB();
bgl::blAttachObjectARB(tmpProg, tmpVert);
bgl::blAttachObjectARB(tmpProg, tmpFrag);
bgl::blLinkProgramARB(tmpProg);
bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
tmpProg = glCreateProgramObjectARB();
glAttachObjectARB(tmpProg, tmpVert);
glAttachObjectARB(tmpProg, tmpFrag);
glLinkProgramARB(tmpProg);
glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
if(proglen > 0 && proglen < MAX_LOG_LEN) {
logInf = (char*)MEM_mallocN(proglen, "prog-log");
bgl::blGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
if(char_len >0) {
spit("---- GLSL Program ----");
spit(logInf);
@ -365,24 +340,24 @@ bool BL_Shader::LinkProgram()
// set
mShader = tmpProg;
bgl::blDeleteObjectARB(tmpVert);
bgl::blDeleteObjectARB(tmpFrag);
glDeleteObjectARB(tmpVert);
glDeleteObjectARB(tmpFrag);
mOk = 1;
mError = 0;
return true;
programError:
if(tmpVert) {
bgl::blDeleteObjectARB(tmpVert);
glDeleteObjectARB(tmpVert);
tmpVert=0;
}
if(tmpFrag) {
bgl::blDeleteObjectARB(tmpFrag);
glDeleteObjectARB(tmpFrag);
tmpFrag=0;
}
if(tmpProg) {
bgl::blDeleteObjectARB(tmpProg);
glDeleteObjectARB(tmpProg);
tmpProg=0;
}
@ -390,9 +365,6 @@ programError:
mUse = 0;
mError = 1;
return false;
#else
return false;
#endif//GL_ARB_shader_objects
}
const char *BL_Shader::GetVertPtr()
@ -428,15 +400,13 @@ unsigned int BL_Shader::GetProg()
void BL_Shader::SetSampler(int loc, int unit)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
bgl::blUniform1iARB(loc, unit);
glUniform1iARB(loc, unit);
}
#endif
}
//
//void BL_Shader::InitializeSampler(int unit, BL_Texture* texture)
@ -449,31 +419,28 @@ void BL_Shader::SetSampler(int loc, int unit)
void BL_Shader::SetProg(bool enable)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
if( mShader != 0 && mOk && enable) {
bgl::blUseProgramObjectARB(mShader);
glUseProgramObjectARB(mShader);
}
else {
bgl::blUseProgramObjectARB(0);
glUseProgramObjectARB(0);
}
}
#endif
}
void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
{
#ifdef GL_ARB_shader_objects
if(!Ok() || !mPreDef.size())
return;
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
MT_Matrix4x4 model;
@ -578,210 +545,185 @@ void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
}
}
}
#endif
}
int BL_Shader::GetAttribLocation(const STR_String& name)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
return bgl::blGetAttribLocationARB(mShader, name.ReadPtr());
return glGetAttribLocationARB(mShader, name.ReadPtr());
}
#endif
return -1;
}
void BL_Shader::BindAttribute(const STR_String& attr, int loc)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
bgl::blBindAttribLocationARB(mShader, loc, attr.ReadPtr());
glBindAttribLocationARB(mShader, loc, attr.ReadPtr());
}
#endif
}
int BL_Shader::GetUniformLocation(const STR_String& name)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
MT_assert(mShader!=0);
int location = bgl::blGetUniformLocationARB(mShader, name.ReadPtr());
int location = glGetUniformLocationARB(mShader, name.ReadPtr());
if(location == -1)
spit("Invalid uniform value: " << name.ReadPtr() << ".");
return location;
}
#endif
return -1;
}
void BL_Shader::SetUniform(int uniform, const MT_Tuple2& vec)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[2];
vec.getValue(value);
bgl::blUniform2fvARB(uniform, 1, value);
glUniform2fvARB(uniform, 1, value);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const MT_Tuple3& vec)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[3];
vec.getValue(value);
bgl::blUniform3fvARB(uniform, 1, value);
glUniform3fvARB(uniform, 1, value);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const MT_Tuple4& vec)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[4];
vec.getValue(value);
bgl::blUniform4fvARB(uniform, 1, value);
glUniform4fvARB(uniform, 1, value);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const unsigned int& val)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
bgl::blUniform1iARB(uniform, val);
glUniform1iARB(uniform, val);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const int val)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
bgl::blUniform1iARB(uniform, val);
glUniform1iARB(uniform, val);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const float& val)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
bgl::blUniform1fARB(uniform, val);
glUniform1fARB(uniform, val);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[16];
vec.getValue(value);
bgl::blUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
glUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[9];
value[0] = (float)vec[0][0]; value[1] = (float)vec[1][0]; value[2] = (float)vec[2][0];
value[3] = (float)vec[0][1]; value[4] = (float)vec[1][1]; value[5] = (float)vec[2][1];
value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[7] = (float)vec[2][2];
bgl::blUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
glUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const float* val, int len)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
if(len == 2)
bgl::blUniform2fvARB(uniform, 1,(GLfloat*)val);
glUniform2fvARB(uniform, 1,(GLfloat*)val);
else if (len == 3)
bgl::blUniform3fvARB(uniform, 1,(GLfloat*)val);
glUniform3fvARB(uniform, 1,(GLfloat*)val);
else if (len == 4)
bgl::blUniform4fvARB(uniform, 1,(GLfloat*)val);
glUniform4fvARB(uniform, 1,(GLfloat*)val);
else
MT_assert(0);
}
#endif
}
void BL_Shader::SetUniform(int uniform, const int* val, int len)
{
#ifdef GL_ARB_shader_objects
if( RAS_EXT_support._ARB_fragment_shader &&
RAS_EXT_support._ARB_vertex_shader &&
RAS_EXT_support._ARB_shader_objects
if( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
if(len == 2)
bgl::blUniform2ivARB(uniform, 1, (GLint*)val);
glUniform2ivARB(uniform, 1, (GLint*)val);
else if (len == 3)
bgl::blUniform3ivARB(uniform, 1, (GLint*)val);
glUniform3ivARB(uniform, 1, (GLint*)val);
else if (len == 4)
bgl::blUniform4ivARB(uniform, 1, (GLint*)val);
glUniform4ivARB(uniform, 1, (GLint*)val);
else
MT_assert(0);
}
#endif
}
@ -849,7 +791,6 @@ PyParentObject BL_Shader::Parents[] = {
KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProgram)" )
{
#ifdef GL_ARB_shader_objects
if(mShader !=0 && mOk )
{
// already set...
@ -862,7 +803,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
vertProg = v;
fragProg = f;
if( LinkProgram() ) {
bgl::blUseProgramObjectARB( mShader );
glUseProgramObjectARB( mShader );
mUse = apply!=0;
Py_Return;
}
@ -871,24 +812,19 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
mUse = 0;
Py_Return;
}
return NULL;
#else
Py_Return;
#endif
}
KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
{
#ifdef GL_ARB_shader_objects
ClearUniforms();
bgl::blUseProgramObjectARB(0);
glUseProgramObjectARB(0);
bgl::blDeleteObjectARB(mShader);
glDeleteObjectARB(mShader);
mShader = 0;
mOk = 0;
mUse = 0;
#endif
Py_Return;
}
@ -909,7 +845,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, getFragmentProg ,"getFragmentProg( )" )
KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
{
#ifdef GL_ARB_shader_objects
if(mError) {
Py_INCREF(Py_None);
return Py_None;
@ -919,15 +854,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
return NULL;
}
int stat = 0;
bgl::blValidateProgramARB(mShader);
bgl::blGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
glValidateProgramARB(mShader);
glGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
if(stat > 0 && stat < MAX_LOG_LEN) {
int char_len=0;
char *logInf = (char*)MEM_mallocN(stat, "validate-log");
bgl::blGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
glGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
if(char_len >0) {
spit("---- GLSL Validation ----");
spit(logInf);
@ -935,7 +870,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
MEM_freeN(logInf);
logInf=0;
}
#endif//GL_ARB_shader_objects
Py_Return;
}
@ -1412,7 +1346,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
{
#ifdef GL_ARB_shader_objects
if(mError) {
Py_INCREF(Py_None);
return Py_None;
@ -1424,11 +1357,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
return NULL;
}
mAttr=SHD_TANGENT;
bgl::blUseProgramObjectARB(mShader);
bgl::blBindAttribLocationARB(mShader, mAttr, "Tangent");
glUseProgramObjectARB(mShader);
glBindAttribLocationARB(mShader, mAttr, "Tangent");
Py_Return;
}
#endif
return NULL;
}

161
source/gameengine/Ketsji/BL_Texture.cpp
View File

@ -1,19 +1,6 @@
// ------------------------------------
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
/* #if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else */
#include <GL/glu.h>
/* #endif */
#endif
#include "GL/glew.h"
#include <iostream>
#include <map>
@ -30,15 +17,11 @@
#include "BLI_blenlib.h"
#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
#include "RAS_OpenGLRasterizer/ARB_multitexture.h"
#include "RAS_ICanvas.h"
#include "RAS_Rect.h"
#include "KX_GameObject.h"
using namespace bgl;
#define spit(x) std::cout << x << std::endl;
#include "MEM_guardedalloc.h"
@ -220,9 +203,7 @@ void BL_Texture::InitNonPow2Tex(unsigned int *pix,int x,int y,bool mipmap)
bool BL_Texture::InitCubeMap(int unit, EnvMap *cubemap)
{
#ifdef GL_ARB_texture_cube_map
if (!RAS_EXT_support._ARB_texture_cube_map)
if (!GLEW_ARB_texture_cube_map)
{
spit("cubemaps not supported");
mOk = false;
@ -312,9 +293,8 @@ bool BL_Texture::InitCubeMap(int unit, EnvMap *cubemap)
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#ifdef GL_VERSION_1_2
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
#endif
if(GLEW_VERSION_1_2)
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
if (needs_split)
my_free_envmapdata(cubemap);
@ -326,13 +306,6 @@ bool BL_Texture::InitCubeMap(int unit, EnvMap *cubemap)
mOk = IsValid();
return mOk;
#else
mOk = false;
return mOk;
#endif//GL_ARB_texture_cube_map
}
bool BL_Texture::IsValid()
@ -362,58 +335,40 @@ int BL_Texture::GetMaxUnits()
{
GLint unit=0;
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(RAS_EXT_support._ARB_multitexture) {
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &unit);
return (MAXTEX>=unit?unit:MAXTEX);
}
if(GLEW_ARB_multitexture) {
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &unit);
return (MAXTEX>=unit?unit:MAXTEX);
}
#endif
return 0;
}
void BL_Texture::ActivateFirst()
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
}
#endif
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void BL_Texture::ActivateUnit(int unit)
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(RAS_EXT_support._ARB_multitexture)
if(unit <= MAXTEX)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB+unit);
}
#endif
if(GLEW_ARB_multitexture)
if(unit <= MAXTEX)
glActiveTextureARB(GL_TEXTURE0_ARB+unit);
}
void BL_Texture::DisableUnit()
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
}
#endif
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
#ifdef GL_ARB_texture_cube_map
if(RAS_EXT_support._ARB_texture_cube_map && glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
if(GLEW_ARB_texture_cube_map && glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
else
#endif
{
if (glIsEnabled(GL_TEXTURE_2D))
glDisable(GL_TEXTURE_2D);
@ -429,56 +384,45 @@ void BL_Texture::DisableUnit()
void BL_Texture::DisableAllTextures()
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
glDisable(GL_BLEND);
for(int i=0; i<MAXTEX; i++) {
if(RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
glDisable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
}
if(RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
for(int i=0; i<MAXTEX; i++) {
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+i);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
}
#endif
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void BL_Texture::ActivateTexture()
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(RAS_EXT_support._ARB_multitexture)
bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
#ifdef GL_ARB_texture_cube_map
if (mType == GL_TEXTURE_CUBE_MAP_ARB && RAS_EXT_support._ARB_texture_cube_map)
{
glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTexture );
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
} else
#endif
{
#ifdef GL_ARB_texture_cube_map
if(RAS_EXT_support._ARB_texture_cube_map )
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
#endif
glBindTexture( GL_TEXTURE_2D, mTexture );
glEnable(GL_TEXTURE_2D);
}
if (mType == GL_TEXTURE_CUBE_MAP_ARB && GLEW_ARB_texture_cube_map)
{
glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTexture );
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
}
else {
if(GLEW_ARB_texture_cube_map )
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture( GL_TEXTURE_2D, mTexture );
glEnable(GL_TEXTURE_2D);
}
#endif
}
void BL_Texture::SetMapping(int mode)
@ -492,9 +436,8 @@ void BL_Texture::SetMapping(int mode)
return;
}
#ifdef GL_ARB_texture_cube_map
if( mType == GL_TEXTURE_CUBE_MAP_ARB &&
RAS_EXT_support._ARB_texture_cube_map &&
GLEW_ARB_texture_cube_map &&
mode &USEREFL)
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
@ -508,7 +451,6 @@ void BL_Texture::SetMapping(int mode)
return;
}
else
#endif
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
@ -523,11 +465,7 @@ void BL_Texture::SetMapping(int mode)
void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
{
#ifndef GL_ARB_texture_env_combine
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
return;
#else
if(modulate || !RAS_EXT_support._ARB_texture_env_combine){
if(modulate || !GLEW_ARB_texture_env_combine){
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
return;
}
@ -661,7 +599,6 @@ void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
glTexEnvf( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0);
glEndList();
#endif //!GL_ARB_texture_env_combine
}
int BL_Texture::GetPow2(int n)

1
source/gameengine/Ketsji/CMakeLists.txt
View File

@ -59,6 +59,7 @@ SET(INC
../../../source/blender/blenloader
../../../extern/bullet2/src
../../../extern/solid
../../../extern/glew/include
${PYTHON_INC}
${SDL_INC}
)

309
source/gameengine/Ketsji/KX_BlenderMaterial.cpp
View File

@ -6,22 +6,7 @@
#include <config.h>
#endif
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
/* #if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else
*/
#include <GL/glu.h>
/* #endif */
#endif
#include "GL/glew.h"
#include "KX_BlenderMaterial.h"
#include "BL_Material.h"
@ -37,7 +22,6 @@
#include "RAS_MeshObject.h"
#include "RAS_IRasterizer.h"
#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
#include "RAS_OpenGLRasterizer/ARB_multitexture.h"
extern "C" {
#include "BDR_drawmesh.h"
@ -52,7 +36,6 @@ extern "C" {
#include "DNA_meshdata_types.h"
#include "BKE_mesh.h"
// ------------------------------------
using namespace bgl;
#define spit(x) std::cout << x << std::endl;
//static PyObject *gTextureDict = 0;
@ -81,6 +64,7 @@ KX_BlenderMaterial::KX_BlenderMaterial(
),
mMaterial(data),
mShader(0),
mBlenderShader(0),
mScene(scene),
mUserDefBlend(0),
mModified(0),
@ -100,9 +84,6 @@ KX_BlenderMaterial::KX_BlenderMaterial(
int max = BL_Texture::GetMaxUnits();
mMaterial->num_enabled = enabled>=max?max:enabled;
// base class
m_enabled = mMaterial->num_enabled;
// test the sum of the various modes for equality
// so we can ether accept or reject this material
// as being equal, this is rather important to
@ -144,25 +125,30 @@ void KX_BlenderMaterial::OnConstruction()
if (mConstructed)
// when material are reused between objects
return;
// for each unique material...
int i;
for(i=0; i<mMaterial->num_enabled; i++) {
if( mMaterial->mapping[i].mapping & USEENV ) {
if(!RAS_EXT_support._ARB_texture_cube_map) {
spit("CubeMap textures not supported");
continue;
}
if(!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
else {
if( mMaterial->img[i] ) {
if( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
if(mMaterial->glslmat) {
SetBlenderGLSLShader();
}
else {
// for each unique material...
int i;
for(i=0; i<mMaterial->num_enabled; i++) {
if( mMaterial->mapping[i].mapping & USEENV ) {
if(!GLEW_ARB_texture_cube_map) {
spit("CubeMap textures not supported");
continue;
}
if(!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
mMaterial->matname<< ", image will not be available");
}
else {
if( mMaterial->img[i] ) {
if( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
}
}
}
@ -176,11 +162,17 @@ void KX_BlenderMaterial::OnExit()
if( mShader ) {
//note, the shader here is allocated, per unique material
//and this function is called per face
mShader->SetProg(0);
mShader->SetProg(false);
delete mShader;
mShader = 0;
}
if( mBlenderShader ) {
mBlenderShader->SetProg(false);
delete mBlenderShader;
mBlenderShader = 0;
}
BL_Texture::ActivateFirst();
for(int i=0; i<mMaterial->num_enabled; i++) {
BL_Texture::ActivateUnit(i);
@ -195,7 +187,7 @@ void KX_BlenderMaterial::OnExit()
void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
{
MT_assert(RAS_EXT_support._ARB_shader_objects && mShader);
MT_assert(GLEW_ARB_shader_objects && mShader);
int i;
if( !enable || !mShader->Ok() ) {
@ -229,10 +221,23 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
}
}
void KX_BlenderMaterial::setBlenderShaderData( bool enable, RAS_IRasterizer *ras)
{
if( !enable || !mBlenderShader->Ok() ) {
// frame cleanup.
mBlenderShader->SetProg(false);
BL_Texture::DisableAllTextures();
return;
}
BL_Texture::DisableAllTextures();
mBlenderShader->SetProg(true);
mBlenderShader->ApplyShader();
}
void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
{
if(RAS_EXT_support._ARB_shader_objects && mShader)
if(GLEW_ARB_shader_objects && mShader)
mShader->SetProg(false);
BL_Texture::DisableAllTextures();
@ -301,14 +306,10 @@ KX_BlenderMaterial::ActivatShaders(
cachingInfo = GetCachingInfo();
if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED ) {
if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
tmp->setShaderData( true, rasty);
rasty->EnableTextures(true);
}
else {
else
tmp->setShaderData( false, rasty);
rasty->EnableTextures(false);
}
if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
rasty->SetCullFace(false);
@ -330,24 +331,28 @@ KX_BlenderMaterial::ActivatShaders(
}
void
KX_BlenderMaterial::ActivateMat(
RAS_IRasterizer* rasty,
TCachingInfo& cachingInfo
)const
KX_BlenderMaterial::ActivateBlenderShaders(
RAS_IRasterizer* rasty,
TCachingInfo& cachingInfo)const
{
KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
// reset...
if(tmp->mMaterial->IsShared())
cachingInfo =0;
if (GetCachingInfo() != cachingInfo) {
if (!cachingInfo)
tmp->setTexData( false,rasty );
if (!cachingInfo)
tmp->setBlenderShaderData(false, rasty);
cachingInfo = GetCachingInfo();
if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
tmp->setTexData( true,rasty );
if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
tmp->setBlenderShaderData(true, rasty);
rasty->EnableTextures(true);
}
else{
tmp->setTexData( false,rasty);
else {
tmp->setBlenderShaderData(false, rasty);
rasty->EnableTextures(false);
}
@ -365,11 +370,48 @@ KX_BlenderMaterial::ActivateMat(
else
rasty->SetLines(false);
}
ActivatGLMaterials(rasty);
mBlenderShader->SetTexCoords(rasty);
}
void
KX_BlenderMaterial::ActivateMat(
RAS_IRasterizer* rasty,
TCachingInfo& cachingInfo
)const
{
KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
if (GetCachingInfo() != cachingInfo) {
if (!cachingInfo)
tmp->setTexData( false,rasty );
cachingInfo = GetCachingInfo();
if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
tmp->setTexData( true,rasty );
else
tmp->setTexData( false,rasty);
if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
rasty->SetCullFace(false);
else
rasty->SetCullFace(true);
if (((mMaterial->ras_mode &WIRE)!=0) || mMaterial->mode & RAS_IRasterizer::KX_LINES)
{
if((mMaterial->ras_mode &WIRE)!=0)
rasty->SetCullFace(false);
rasty->SetLines(true);
}
else
rasty->SetLines(false);
}
ActivatGLMaterials(rasty);
ActivateTexGen(rasty);
}
bool
KX_BlenderMaterial::Activate(
RAS_IRasterizer* rasty,
@ -377,7 +419,7 @@ KX_BlenderMaterial::Activate(
)const
{
bool dopass = false;
if( RAS_EXT_support._ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
if( GLEW_ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
if( (mPass++) < mShader->getNumPass() ) {
ActivatShaders(rasty, cachingInfo);
dopass = true;
@ -390,6 +432,18 @@ KX_BlenderMaterial::Activate(
return dopass;
}
}
else if( GLEW_ARB_shader_objects && ( mBlenderShader && mBlenderShader->Ok() ) ) {
if( (mPass++) == 0 ) {
ActivateBlenderShaders(rasty, cachingInfo);
dopass = true;
return dopass;
}
else {
mPass = 0;
dopass = false;
return dopass;
}
}
else {
switch (mPass++)
{
@ -408,34 +462,39 @@ KX_BlenderMaterial::Activate(
void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterizer* rasty) const
{
if(mShader && RAS_EXT_support._ARB_shader_objects)
if(mShader && GLEW_ARB_shader_objects)
mShader->Update(ms, rasty);
if(mBlenderShader && GLEW_ARB_shader_objects)
mBlenderShader->Update(ms, rasty);
}
void KX_BlenderMaterial::ActivatGLMaterials( RAS_IRasterizer* rasty )const
{
rasty->SetSpecularity(
mMaterial->speccolor[0]*mMaterial->spec_f,
mMaterial->speccolor[1]*mMaterial->spec_f,
mMaterial->speccolor[2]*mMaterial->spec_f,
mMaterial->spec_f
);
if(!mBlenderShader) {
rasty->SetSpecularity(
mMaterial->speccolor[0]*mMaterial->spec_f,
mMaterial->speccolor[1]*mMaterial->spec_f,
mMaterial->speccolor[2]*mMaterial->spec_f,
mMaterial->spec_f
);
rasty->SetShinyness( mMaterial->hard );
rasty->SetShinyness( mMaterial->hard );
rasty->SetDiffuse(
mMaterial->matcolor[0]*mMaterial->ref+mMaterial->emit,
mMaterial->matcolor[1]*mMaterial->ref+mMaterial->emit,
mMaterial->matcolor[2]*mMaterial->ref+mMaterial->emit,
1.0f);
rasty->SetDiffuse(
mMaterial->matcolor[0]*mMaterial->ref+mMaterial->emit,
mMaterial->matcolor[1]*mMaterial->ref+mMaterial->emit,
mMaterial->matcolor[2]*mMaterial->ref+mMaterial->emit,
1.0f);
rasty->SetEmissive(
mMaterial->matcolor[0]*mMaterial->emit,
mMaterial->matcolor[1]*mMaterial->emit,
mMaterial->matcolor[2]*mMaterial->emit,
1.0 );
rasty->SetEmissive(
mMaterial->matcolor[0]*mMaterial->emit,
mMaterial->matcolor[1]*mMaterial->emit,
mMaterial->matcolor[2]*mMaterial->emit,
1.0 );
rasty->SetAmbient(mMaterial->amb);
}
rasty->SetAmbient(mMaterial->amb);
if (mMaterial->material)
rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
}
@ -443,34 +502,46 @@ void KX_BlenderMaterial::ActivatGLMaterials( RAS_IRasterizer* rasty )const
void KX_BlenderMaterial::ActivateTexGen(RAS_IRasterizer *ras) const
{
if(mShader && RAS_EXT_support._ARB_shader_objects)
if(mShader->GetAttribute() == BL_Shader::SHD_TANGENT)
ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT);
for(int i=0; i<mMaterial->num_enabled; i++) {
int mode = mMaterial->mapping[i].mapping;
if (mode &USECUSTOMUV)
{
STR_String str = mMaterial->mapping[i].uvCoName;
if (!str.IsEmpty())
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_UV2, i);
continue;
if(ras->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
ras->SetAttribNum(0);
if(mShader && GLEW_ARB_shader_objects) {
if(mShader->GetAttribute() == BL_Shader::SHD_TANGENT) {
ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT, 1);
ras->SetAttribNum(2);
}
}
if( mode &(USEREFL|USEOBJ))
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_GEN, i);
else if(mode &USEORCO)
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_ORCO, i);
else if(mode &USENORM)
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_NORM, i);
else if(mode &USEUV)
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_UV1, i);
else if(mode &USETANG)
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXTANGENT, i);
else
ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
ras->SetTexCoordNum(mMaterial->num_enabled);
for(int i=0; i<mMaterial->num_enabled; i++) {
int mode = mMaterial->mapping[i].mapping;
if (mode &USECUSTOMUV)
{
STR_String str = mMaterial->mapping[i].uvCoName;
if (!str.IsEmpty())
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_UV2, i);
continue;
}
if( mode &(USEREFL|USEOBJ))
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_GEN, i);
else if(mode &USEORCO)
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_ORCO, i);
else if(mode &USENORM)
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_NORM, i);
else if(mode &USEUV)
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_UV1, i);
else if(mode &USETANG)
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXTANGENT, i);
else
ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
}
ras->EnableTextures(true);
}
else
ras->EnableTextures(false);
}
bool KX_BlenderMaterial::setDefaultBlending()
@ -503,8 +574,7 @@ void KX_BlenderMaterial::setTexMatrixData(int i)
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
#ifdef GL_ARB_texture_cube_map
if( RAS_EXT_support._ARB_texture_cube_map &&
if( GLEW_ARB_texture_cube_map &&
mTextures[i].GetTextureType() == GL_TEXTURE_CUBE_MAP_ARB &&
mMaterial->mapping[i].mapping & USEREFL) {
glScalef(
@ -514,7 +584,6 @@ void KX_BlenderMaterial::setTexMatrixData(int i)
);
}
else
#endif
{
glScalef(
mMaterial->mapping[i].scale[0],
@ -663,28 +732,23 @@ int KX_BlenderMaterial::_setattr(const STR_String& attr, PyObject *pyvalue)
KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
{
#ifdef GL_ARB_fragment_shader
if( !RAS_EXT_support._ARB_fragment_shader) {
if( !GLEW_ARB_fragment_shader) {
if(!mModified)
spit("Fragment shaders not supported");
mModified = true;
Py_Return;
}
#endif
#ifdef GL_ARB_vertex_shader
if( !RAS_EXT_support._ARB_vertex_shader) {
if( !GLEW_ARB_vertex_shader) {
if(!mModified)
spit("Vertex shaders not supported");
mModified = true;
Py_Return;
}
#endif
#ifdef GL_ARB_shader_objects
if(!RAS_EXT_support._ARB_shader_objects) {
if(!GLEW_ARB_shader_objects) {
if(!mModified)
spit("GLSL not supported");
mModified = true;
@ -723,13 +787,20 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
}
PyErr_Format(PyExc_ValueError, "GLSL Error");
return NULL;
#else
Py_Return;
#endif//GL_ARB_shader_objects
}
void KX_BlenderMaterial::SetBlenderGLSLShader(void)
{
if(!mBlenderShader)
mBlenderShader = new BL_BlenderShader(mMaterial->material);
if(!mBlenderShader->Ok()) {
delete mBlenderShader;
mBlenderShader = 0;
}
}
KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getMaterialIndex, "getMaterialIndex()")
{
return PyInt_FromLong( mMaterial->material_index );

13
source/gameengine/Ketsji/KX_BlenderMaterial.h
View File

@ -8,6 +8,7 @@
#include "BL_Material.h"
#include "BL_Texture.h"
#include "BL_Shader.h"
#include "BL_BlenderShader.h"
#include "PyObjectPlus.h"
@ -60,6 +61,10 @@ public:
TCachingInfo& cachingInfo
)const;
void ActivateBlenderShaders(
RAS_IRasterizer* rasty,
TCachingInfo& cachingInfo
)const;
MTFace* GetMTFace(void) const;
unsigned int* GetMCol(void) const;
@ -86,8 +91,9 @@ public:
// pre calculate to avoid pops/lag at startup
virtual void OnConstruction( );
private:
BL_Material* mMaterial;
BL_Shader* mShader;
BL_Material* mMaterial;
BL_Shader* mShader;
BL_BlenderShader* mBlenderShader;
KX_Scene* mScene;
BL_Texture mTextures[MAXTEX]; // texture array
bool mUserDefBlend;
@ -95,12 +101,15 @@ private:
bool mModified;
bool mConstructed; // if false, don't clean on exit
void SetBlenderGLSLShader();
void ActivatGLMaterials( RAS_IRasterizer* rasty )const;
void ActivateTexGen( RAS_IRasterizer *ras ) const;
// message centers
void setTexData( bool enable,RAS_IRasterizer *ras);
void setBlenderShaderData( bool enable, RAS_IRasterizer *ras);
void setShaderData( bool enable, RAS_IRasterizer *ras);
bool setDefaultBlending();

4
source/gameengine/Ketsji/KX_GameObject.cpp
View File

@ -81,8 +81,8 @@ KX_GameObject::KX_GameObject(
m_bVisible(true),
m_pPhysicsController1(NULL),
m_pPhysicsEnvironment(NULL),
m_isDeformable(false),
m_pHitObject(NULL)
m_pHitObject(NULL),
m_isDeformable(false)
{
m_ignore_activity_culling = false;
m_pClient_info = new KX_ClientObjectInfo(this, KX_ClientObjectInfo::ACTOR);

3
source/gameengine/Ketsji/KX_ISceneConverter.h
View File

@ -74,6 +74,9 @@ public:
virtual void SetMaterials(bool val) =0;
virtual bool GetMaterials()=0;
// use blender glsl materials
virtual void SetGLSLMaterials(bool val) =0;
virtual bool GetGLSLMaterials()=0;
};
#endif //__KX_ISCENECONVERTER_H

70
source/gameengine/Ketsji/KX_PythonInit.cpp
View File

@ -28,25 +28,7 @@
* Initialize Python thingies.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
/* #if defined(__sun__) && !defined(__sparc__)
#include <mesa/glu.h>
#else */
#include <GL/glu.h>
/* #endif */
#endif
#include "GL/glew.h"
#include <stdlib.h>
@ -310,17 +292,13 @@ static PyObject* gPyGetCurrentScene(PyObject* self,
static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
{
#define pprint(x) std::cout << x << std::endl;
bgl::BL_EXTInfo ext = bgl::RAS_EXT_support;
bool count=0;
bool support=0;
pprint("Supported Extensions...");
#ifdef GL_ARB_shader_objects
pprint(" GL_ARB_shader_objects supported? "<< (ext._ARB_shader_objects?"yes.":"no."));
pprint(" GL_ARB_shader_objects supported? "<< (GLEW_ARB_shader_objects?"yes.":"no."));
count = 1;
#endif
#ifdef GL_ARB_vertex_shader
support= ext._ARB_vertex_shader;
support= GLEW_ARB_vertex_shader;
pprint(" GL_ARB_vertex_shader supported? "<< (support?"yes.":"no."));
count = 1;
if(support){
@ -339,9 +317,8 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
pprint(" Max combined texture units." << max);
pprint("");
}
#endif
#ifdef GL_ARB_fragment_shader
support=ext._ARB_fragment_shader;
support=GLEW_ARB_fragment_shader;
pprint(" GL_ARB_fragment_shader supported? "<< (support?"yes.":"no."));
count = 1;
if(support){
@ -351,9 +328,8 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
pprint(" Max uniform components." << max);
pprint("");
}
#endif
#ifdef GL_ARB_texture_cube_map
support = ext._ARB_texture_cube_map;
support = GLEW_ARB_texture_cube_map;
pprint(" GL_ARB_texture_cube_map supported? "<< (support?"yes.":"no."));
count = 1;
if(support){
@ -363,25 +339,21 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
pprint(" Max cubemap size." << size);
pprint("");
}
#endif
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
support = ext._ARB_multitexture;
count = 1;
pprint(" GL_ARB_multitexture supported? "<< (support?"yes.":"no."));
if(support){
pprint(" ----------Details----------");
int units=0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&units);
pprint(" Max texture units available. " << units);
pprint("");
}
}
#endif
#ifdef GL_ARB_texture_env_combine
pprint(" GL_ARB_texture_env_combine supported? "<< (ext._ARB_texture_env_combine?"yes.":"no."));
support = GLEW_ARB_multitexture;
count = 1;
#endif
pprint(" GL_ARB_multitexture supported? "<< (support?"yes.":"no."));
if(support){
pprint(" ----------Details----------");
int units=0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&units);
pprint(" Max texture units available. " << units);
pprint("");
}
pprint(" GL_ARB_texture_env_combine supported? "<< (GLEW_ARB_texture_env_combine?"yes.":"no."));
count = 1;
if(!count)
pprint("No extenstions are used in this build");

1
source/gameengine/Ketsji/Makefile
View File

@ -36,6 +36,7 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += $(OGL_CPPFLAGS)
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) -I../../blender/python
CPPFLAGS += -I$(NAN_STRING)/include

2
source/gameengine/Ketsji/SConscript
View File

@ -18,7 +18,7 @@ incs += ' #source/gameengine/SceneGraph #source/gameengine/Physics/common #sourc
incs += ' #source/gameengine/Physics/BlOde #source/gameengine/Physics/Dummy'
incs += ' #source/gameengine/Physics/Sumo #source/gameengine/Physics/Sumo/include'
incs += ' #source/gameengine/Physics/Sumo/Fuzzics/include #source/gameengine/Network/LoopBackNetwork'
incs += ' #source/blender/misc #source/blender/blenloader'
incs += ' #source/blender/misc #source/blender/blenloader #extern/glew/include'
cflags = []
if env['OURPLATFORM'] == 'win32-vc':

1
source/gameengine/Rasterizer/CMakeLists.txt
View File

@ -31,6 +31,7 @@ SET(INC
../../../source/kernel/gen_system
../../../intern/string
../../../intern/moto/include
../../../extern/glew/include
)
BLENDERLIB(bf_rasterizer "${SRC}" "${INC}")

1
source/gameengine/Rasterizer/Makefile
View File

@ -35,6 +35,7 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I$(NAN_STRING)/include
CPPFLAGS += -I$(NAN_MOTO)/include

63
source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
View File

@ -46,18 +46,7 @@
#include "RAS_2DFilterManager.h"
#include <iostream>
#ifdef WIN32
// OpenGL gl.h needs 'windows.h' on windows platforms
#include <windows.h>
#endif //WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
#include "GL/glew.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
@ -69,7 +58,7 @@ texturewidth(-1), textureheight(-1),
canvaswidth(-1), canvasheight(-1),
numberoffilters(0),texname(-1)
{
isshadersupported = bgl::QueryVersion(2,0);
isshadersupported = GLEW_VERSION_2_0;
if(!isshadersupported)
{
std::cout<<"shaders not supported!" << std::endl;
@ -93,14 +82,14 @@ unsigned int RAS_2DFilterManager::CreateShaderProgram(char* shadersource)
{
GLuint program = 0;
#if defined(GL_ARB_shader_objects) && defined(WITH_GLEXT)
GLuint fShader = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER);
GLuint fShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
GLint success;
bgl::blShaderSourceARB(fShader, 1, (const char**)&shadersource, NULL);
glShaderSourceARB(fShader, 1, (const char**)&shadersource, NULL);
bgl::blCompileShaderARB(fShader);
glCompileShaderARB(fShader);
bgl::blGetObjectParameterivARB(fShader, GL_COMPILE_STATUS, &success);
glGetObjectParameterivARB(fShader, GL_COMPILE_STATUS, &success);
if(!success)
{
/*Shader Comile Error*/
@ -108,11 +97,11 @@ unsigned int RAS_2DFilterManager::CreateShaderProgram(char* shadersource)
return 0;
}
program = bgl::blCreateProgramObjectARB();
bgl::blAttachObjectARB(program, fShader);
program = glCreateProgramObjectARB();
glAttachObjectARB(program, fShader);
bgl::blLinkProgramARB(program);
bgl::blGetObjectParameterivARB(program, GL_LINK_STATUS, &success);
glLinkProgramARB(program);
glGetObjectParameterivARB(program, GL_LINK_STATUS, &success);
if (!success)
{
/*Program Link Error*/
@ -120,8 +109,8 @@ unsigned int RAS_2DFilterManager::CreateShaderProgram(char* shadersource)
return 0;
}
bgl::blValidateProgramARB(program);
bgl::blGetObjectParameterivARB(program, GL_VALIDATE_STATUS, &success);
glValidateProgramARB(program);
glGetObjectParameterivARB(program, GL_VALIDATE_STATUS, &success);
if (!success)
{
/*Program Validation Error*/
@ -164,30 +153,30 @@ void RAS_2DFilterManager::StartShaderProgram(unsigned int shaderprogram)
{
#if defined(GL_ARB_shader_objects) && defined(WITH_GLEXT)
GLint uniformLoc;
bgl::blUseProgramObjectARB(shaderprogram);
uniformLoc = bgl::blGetUniformLocationARB(shaderprogram, "bgl_RenderedTexture");
bgl::blActiveTextureARB(GL_TEXTURE0);
glUseProgramObjectARB(shaderprogram);
uniformLoc = glGetUniformLocationARB(shaderprogram, "bgl_RenderedTexture");
glActiveTextureARB(GL_TEXTURE0);
//glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texname);
if (uniformLoc != -1)
{
bgl::blUniform1iARB(uniformLoc, 0);
glUniform1iARB(uniformLoc, 0);
}
uniformLoc = bgl::blGetUniformLocationARB(shaderprogram, "bgl_TextureCoordinateOffset");
uniformLoc = glGetUniformLocationARB(shaderprogram, "bgl_TextureCoordinateOffset");
if (uniformLoc != -1)
{
bgl::blUniform2fvARB(uniformLoc, 9, textureoffsets);
glUniform2fvARB(uniformLoc, 9, textureoffsets);
}
uniformLoc = bgl::blGetUniformLocationARB(shaderprogram, "bgl_RenderedTextureWidth");
uniformLoc = glGetUniformLocationARB(shaderprogram, "bgl_RenderedTextureWidth");
if (uniformLoc != -1)
{
bgl::blUniform1fARB(uniformLoc,texturewidth);
glUniform1fARB(uniformLoc,texturewidth);
}
uniformLoc = bgl::blGetUniformLocationARB(shaderprogram, "bgl_RenderedTextureHeight");
uniformLoc = glGetUniformLocationARB(shaderprogram, "bgl_RenderedTextureHeight");
if (uniformLoc != -1)
{
bgl::blUniform1fARB(uniformLoc,textureheight);
glUniform1fARB(uniformLoc,textureheight);
}
#endif
}
@ -195,7 +184,7 @@ void RAS_2DFilterManager::StartShaderProgram(unsigned int shaderprogram)
void RAS_2DFilterManager::EndShaderProgram()
{
#if defined(GL_ARB_shader_objects) && defined(WITH_GLEXT)
bgl::blUseProgramObjectARB(0);
glUseProgramObjectARB(0);
#endif
}
@ -325,7 +314,7 @@ void RAS_2DFilterManager::EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_Str
if(mode == RAS_2DFILTER_NOFILTER)
{
if(m_filters[pass])
bgl::blDeleteObjectARB(m_filters[pass]);
glDeleteObjectARB(m_filters[pass]);
m_enabled[pass] = 0;
m_filters[pass] = 0;
return;
@ -334,7 +323,7 @@ void RAS_2DFilterManager::EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_Str
if(mode == RAS_2DFILTER_CUSTOMFILTER)
{
if(m_filters[pass])
bgl::blDeleteObjectARB(m_filters[pass]);
glDeleteObjectARB(m_filters[pass]);
m_filters[pass] = CreateShaderProgram(text.Ptr());
m_enabled[pass] = 1;
return;
@ -343,7 +332,7 @@ void RAS_2DFilterManager::EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_Str
if(mode>=RAS_2DFILTER_MOTIONBLUR && mode<=RAS_2DFILTER_INVERT)
{
if(m_filters[pass])
bgl::blDeleteObjectARB(m_filters[pass]);
glDeleteObjectARB(m_filters[pass]);
m_filters[pass] = CreateShaderProgram(mode);
m_enabled[pass] = 1;
}

4
source/gameengine/Rasterizer/RAS_CameraData.h
View File

@ -49,12 +49,12 @@ struct RAS_CameraData
m_clipstart(clipstart),
m_clipend(clipend),
m_perspective(perspective),
m_focallength(focallength),
m_viewport(viewport),
m_viewportleft(viewportleft),
m_viewportbottom(viewportbottom),
m_viewportright(viewportright),
m_viewporttop(viewporttop)
m_viewporttop(viewporttop),
m_focallength(focallength)
{
}
};

6
source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
View File

@ -56,7 +56,6 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname,
m_bIsTriangle(bIsTriangle),
m_polymatid(m_newpolymatid++),
m_flag(0),
m_enabled(0),
m_multimode(0)
{
m_shininess = 35.0;
@ -148,10 +147,5 @@ const unsigned int RAS_IPolyMaterial::GetFlag() const
{
return m_flag;
}
const unsigned int RAS_IPolyMaterial::GetEnabled() const
{
return m_enabled;
}
unsigned int RAS_IPolyMaterial::m_newpolymatid = 0;

2
source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
View File

@ -77,7 +77,6 @@ protected:
// will move...
unsigned int m_flag;//MaterialProps
unsigned int m_enabled;// enabled for this mat
int m_multimode; // sum of values
public:
@ -141,7 +140,6 @@ public:
const STR_String& GetMaterialName() const;
const STR_String& GetTextureName() const;
const unsigned int GetFlag() const;
const unsigned int GetEnabled() const;
/*
* PreCalculate texture gen

29
source/gameengine/Rasterizer/RAS_IRasterizer.h
View File

@ -213,17 +213,7 @@ public:
bool useObjectColor,
const MT_Vector4& rgbacolor,
class KX_ListSlot** slot)=0;
/**
* @copydoc IndexPrimitives
* IndexPrimitivesEx will renormalize faces if @param vertexarrays[i].getFlag() & TV_CALCFACENORMAL
*/
virtual void IndexPrimitives_Ex( const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
class RAS_IPolyMaterial* polymat,
class RAS_IRenderTools* rendertools,
bool useObjectColor,
const MT_Vector4& rgbacolor)=0;
/**
* IndexPrimitives_3DText will render text into the polygons.
* The text to be rendered is from @param rendertools client object's text property.
@ -246,16 +236,6 @@ public:
const MT_Vector4& rgbacolor,
class KX_ListSlot** slot)=0;
virtual void IndexPrimitivesMulti_Ex(
const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
class RAS_IPolyMaterial* polymat,
class RAS_IRenderTools* rendertools,
bool useObjectColor,
const MT_Vector4& rgbacolor)=0;
virtual void SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
/* This one should become our final version, methinks. */
/**
@ -389,8 +369,11 @@ public:
virtual void DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
virtual void SetTexCoords(TexCoGen coords, int unit) = 0;
virtual void SetAttrib(int type) = 0;
virtual void SetTexCoordNum(int num) = 0;
virtual void SetAttribNum(int num) = 0;
virtual void SetTexCoord(TexCoGen coords, int unit) = 0;
virtual void SetAttrib(TexCoGen coords, int unit) = 0;
virtual void GetViewMatrix(MT_Matrix4x4 &mat) const = 0;
virtual bool QueryLists(){return false;}

39
source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
View File

@ -177,7 +177,6 @@ bool RAS_MaterialBucket::ActivateMaterial(const MT_Transform& cameratrans, RAS_I
bool dolights = false;
const unsigned int flag = m_material->GetFlag();
if( flag & RAS_BLENDERMAT)
dolights = (flag &RAS_MULTILIGHT)!=0;
else
@ -237,11 +236,10 @@ void RAS_MaterialBucket::RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRa
rendertools, // needed for textprinting on polys
ms.m_bObjectColor,
ms.m_RGBAcolor);
}
// for using glMultiTexCoord
else if(m_material->GetFlag() & RAS_MULTITEX )
else if((m_material->GetFlag() & RAS_MULTITEX))
{
rasty->IndexPrimitivesMulti(
ms.m_mesh->GetVertexCache(m_material),
@ -251,37 +249,10 @@ void RAS_MaterialBucket::RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRa
rendertools,
ms.m_bObjectColor,
ms.m_RGBAcolor,
&ms.m_DisplayList
(ms.m_pDeformer)? 0: &ms.m_DisplayList
);
}
// for using glMultiTexCoord on deformer
else if(m_material->GetFlag() & RAS_DEFMULTI )
{
rasty->IndexPrimitivesMulti_Ex(
ms.m_mesh->GetVertexCache(m_material),
ms.m_mesh->GetIndexCache(m_material),
drawmode,
m_material,
rendertools,
ms.m_bObjectColor,
ms.m_RGBAcolor
);
}
// Use the (slower) IndexPrimitives_Ex which can recalc face normals & such
// for deformed objects - eventually should be extended to recalc ALL normals
else if (ms.m_pDeformer){
rasty->IndexPrimitives_Ex(
ms.m_mesh->GetVertexCache(m_material),
ms.m_mesh->GetIndexCache(m_material),
drawmode,
m_material,
rendertools, // needed for textprinting on polys
ms.m_bObjectColor,
ms.m_RGBAcolor
);
}
// Use the normal IndexPrimitives
else
{
@ -293,7 +264,7 @@ void RAS_MaterialBucket::RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRa
rendertools, // needed for textprinting on polys
ms.m_bObjectColor,
ms.m_RGBAcolor,
&ms.m_DisplayList
(ms.m_pDeformer)? 0: &ms.m_DisplayList
);
}
@ -316,14 +287,14 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans,
//rasty->SetMaterial(*m_material);
int drawmode;
for (T_MeshSlotList::const_iterator it = m_meshSlots.begin();
! (it == m_meshSlots.end()); ++it)
{
rendertools->SetClientObject((*it).m_clientObj);
while (ActivateMaterial(cameratrans, rasty, rendertools, drawmode))
while (ActivateMaterial(cameratrans, rasty, rendertools, drawmode)) {
RenderMeshSlot(cameratrans, rasty, rendertools, *it, drawmode);
}
}
// to reset the eventual GL_CW mode
rendertools->SetClientObject(NULL);

27
source/gameengine/Rasterizer/RAS_MeshObject.cpp
View File

@ -256,27 +256,30 @@ int RAS_MeshObject::FindOrAddVertex(int vtxarray,
const MT_Vector4& tangent,
const unsigned int rgbacolor,
const MT_Vector3& normal,
bool flat,
RAS_IPolyMaterial* mat,
int orgindex)
{
KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
int numverts = ao->m_VertexArrayCache1[vtxarray]->size();//m_VertexArrayCount[vtxarray];
RAS_TexVert newvert(xyz,uv,uv2,tangent,rgbacolor,normal, 0);
RAS_TexVert newvert(xyz,uv,uv2,tangent,rgbacolor,normal, flat? TV_CALCFACENORMAL: 0);
#define KX_FIND_SHARED_VERTICES
#ifdef KX_FIND_SHARED_VERTICES
for (std::vector<RAS_MatArrayIndex>::iterator it = m_xyz_index_to_vertex_index_mapping[orgindex].begin();
it != m_xyz_index_to_vertex_index_mapping[orgindex].end();
it++)
{
if ((*it).m_arrayindex1 == ao->m_index1 &&
(*it).m_array == vtxarray &&
*(*it).m_matid == *mat &&
(*ao->m_VertexArrayCache1[vtxarray])[(*it).m_index].closeTo(&newvert)
)
if(!flat) {
for (std::vector<RAS_MatArrayIndex>::iterator it = m_xyz_index_to_vertex_index_mapping[orgindex].begin();
it != m_xyz_index_to_vertex_index_mapping[orgindex].end();
it++)
{
return (*it).m_index;
if ((*it).m_arrayindex1 == ao->m_index1 &&
(*it).m_array == vtxarray &&
*(*it).m_matid == *mat &&
(*ao->m_VertexArrayCache1[vtxarray])[(*it).m_index].closeTo(&newvert)
)
{
return (*it).m_index;
}
}
}
#endif // KX_FIND_SHARED_VERTICES

1
source/gameengine/Rasterizer/RAS_MeshObject.h
View File

@ -238,6 +238,7 @@ public:
const MT_Vector4& tangent,
const unsigned int rgbacolor,
const MT_Vector3& normal,
bool flat,
RAS_IPolyMaterial* mat,
int orgindex
);

150
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/ARB_multitexture.h
View File

@ -1,150 +0,0 @@
#ifndef __ARB_MULTITEXTURE_H__
#define __ARB_MULTITEXTURE_H__
/*
*/
/* ----------------------------------------------------------------------------
GL_ARB_multitexture
---------------------------------------------------------------------------- */
#ifdef GL_ARB_multitexture
#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_ACTIVE_TEXTURE_ARB 0x84E0
#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
#endif
/* ----------------------------------------------------------------------------
GL_ARB_texture_env_combine
---------------------------------------------------------------------------- */
#ifdef GL_ARB_texture_env_combine
#define GL_COMBINE_ARB 0x8570
#define GL_COMBINE_RGB_ARB 0x8571
#define GL_COMBINE_ALPHA_ARB 0x8572
#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 GL_RGB_SCALE_ARB 0x8573
#define GL_ADD_SIGNED_ARB 0x8574
#define GL_INTERPOLATE_ARB 0x8575
#define GL_SUBTRACT_ARB 0x84E7
#define GL_CONSTANT_ARB 0x8576
#define GL_PRIMARY_COLOR_ARB 0x8577
#define GL_PREVIOUS_ARB 0x8578
#endif
/* ----------------------------------------------------------------------------
GL_ARB_texture_cube_map
---------------------------------------------------------------------------- */
#ifdef GL_ARB_texture_cube_map
#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
#endif
/* ----------------------------------------------------------------------------
GL_ARB_shader_objects
---------------------------------------------------------------------------- */
#ifdef GL_ARB_shader_objects
#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
#endif
/* ----------------------------------------------------------------------------
GL_ARB_vertex_shader
---------------------------------------------------------------------------- */
#ifdef GL_ARB_vertex_shader
#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
#endif
/* ----------------------------------------------------------------------------
GL_ARB_fragment_shader
---------------------------------------------------------------------------- */
#ifdef GL_ARB_fragment_shader
#define GL_FRAGMENT_SHADER_ARB 0x8B30
#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B
#endif
/* ----------------------------------------------------------------------------
GL_ARB_depth_texture
---------------------------------------------------------------------------- */
#ifndef GL_ARB_depth_texture
#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
#endif
#endif//__ARB_MULTITEXTURE_H__

1
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
View File

@ -31,6 +31,7 @@ SET(INC
../../../../intern/string
../../../../intern/moto/include
../../../../source/gameengine/Rasterizer
../../../../extern/glew/include
)
BLENDERLIB(bf_oglrasterizer "${SRC}" "${INC}")

12
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/EXT_separate_specular_color.h
View File

@ -1,12 +0,0 @@
#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
#endif
#ifndef GL_VERSION_1_2
#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
#define GL_SINGLE_COLOR 0x81F9
#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
#endif

1
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile
View File

@ -36,6 +36,7 @@ include nan_compile.mk
CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
CPPFLAGS += -I$(NAN_GLEW)/include
CPPFLAGS += -I$(OPENGL_HEADERS)
CPPFLAGS += -I$(NAN_STRING)/include
CPPFLAGS += -I$(NAN_MOTO)/include

674
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp
View File

@ -25,665 +25,43 @@
*
* ***** END GPL LICENSE BLOCK *****
*/
/*
The extension manager's job is to link at runtime OpenGL extension
functions.
Since the various platform have different methods of finding a fn
pointer, this file attempts to encapsulate all that, so it gets a
little messy. Hopefully we can
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef WIN32
# include <windows.h>
# include <GL/gl.h>
#elif defined(__APPLE__)
# include <Carbon/Carbon.h>
# define GL_GLEXT_LEGACY 1
# include <OpenGL/gl.h>
#else /* UNIX */
# include <GL/gl.h>
# include <GL/glx.h>
# include <dlfcn.h>
#endif
#include <vector>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <stdlib.h>
#include "STR_String.h"
#include "RAS_GLExtensionManager.h"
/* -----------------------------------------------------------------------------
Platform specific functions section.
Required Functions:
static void bglInitEntryPoints (void) -- Loads the GL library
static void bglDeallocEntryPoints (void) -- Frees the GL library
static void *bglGetProcAddress(const GLubyte* entry) -- Finds the address of
the GL function entry
*/
#if defined(BGL_NO_EXTENSIONS)
static void bglInitEntryPoints (void) {}
static void bglDeallocEntryPoints (void) {}
static void *bglGetProcAddress(const GLubyte* entry)
{
/* No Extensions! */
return NULL;
}
#elif defined(__APPLE__)
/* http://developer.apple.com/qa/qa2001/qa1188.html */
CFBundleRef gBundleRefOpenGL = NULL;
// -------------------------
static OSStatus bglInitEntryPoints (void)
{
OSStatus err = noErr;
const Str255 frameworkName = "\pOpenGL.framework";
FSRefParam fileRefParam;
FSRef fileRef;
CFURLRef bundleURLOpenGL;
memset(&fileRefParam, 0, sizeof(fileRefParam));
memset(&fileRef, 0, sizeof(fileRef));
fileRefParam.ioNamePtr = frameworkName;
fileRefParam.newRef = &fileRef;
// Frameworks directory/folder
err = FindFolder (kSystemDomain, kFrameworksFolderType, false,
&fileRefParam.ioVRefNum, (SInt32*)&fileRefParam.ioDirID);
if (noErr != err) {
DebugStr ((unsigned char *)"\pCould not find frameworks folder");
return err;
}
err = PBMakeFSRefSync (&fileRefParam); // make FSRef for folder
if (noErr != err) {
DebugStr ((unsigned char *)"\pCould make FSref to frameworks folder");
return err;
}
// create URL to folder
bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault,
&fileRef);
if (!bundleURLOpenGL) {
DebugStr ((unsigned char *)"\pCould create OpenGL Framework bundle URL");
return paramErr;
}
// create ref to GL's bundle
gBundleRefOpenGL = CFBundleCreate (kCFAllocatorDefault,
bundleURLOpenGL);
if (!gBundleRefOpenGL) {
DebugStr ((unsigned char *)"\pCould not create OpenGL Framework bundle");
return paramErr;
}
CFRelease (bundleURLOpenGL); // release created bundle
// if the code was successfully loaded, look for our function.
if (!CFBundleLoadExecutable (gBundleRefOpenGL)) {
DebugStr ((unsigned char *)"\pCould not load MachO executable");
return paramErr;
}
return err;
}
// -------------------------
static void bglDeallocEntryPoints (void)
{
if (gBundleRefOpenGL != NULL) {
// unload the bundle's code.
CFBundleUnloadExecutable (gBundleRefOpenGL);
CFRelease (gBundleRefOpenGL);
gBundleRefOpenGL = NULL;
}
}
// -------------------------
/*unused*/
static void * bglGetProcAddress (const GLubyte * pszProc)
{
if (!gBundleRefOpenGL)
return NULL;
return CFBundleGetFunctionPointerForName (gBundleRefOpenGL,
CFStringCreateWithCStringNoCopy (NULL,
(const char *) pszProc, CFStringGetSystemEncoding (), NULL));
}
#elif defined(GLX_ARB_get_proc_address)
/* Not all glx.h define PFNGLXGETPROCADDRESSARBPROC !
We define our own if needed. */
#ifdef HAVE_PFNGLXGETPROCADDRESSARBPROC
#define PFNBGLXGETPROCADDRESSARBPROC PFNGLXGETPROCADDRESSARBPROC
#else
typedef void (*(*PFNBGLXGETPROCADDRESSARBPROC)(const GLubyte *procname))();
#endif
void *_getProcAddress(const GLubyte *procName) { return NULL; }
PFNBGLXGETPROCADDRESSARBPROC bglGetProcAddress;
//weird bug related to combination of pthreads,libGL and dlopen
//cannot call dlclose in such environment, causes crashes
//so try to keep a global handle to libGL
void* libGL = 0;
static void bglInitEntryPoints (void)
{
Display *dpy = glXGetCurrentDisplay();
std::vector<STR_String> Xextensions = STR_String(glXQueryExtensionsString(dpy, DefaultScreen(dpy))).Explode(' ');
if (std::find(Xextensions.begin(), Xextensions.end(), "GLX_ARB_get_proc_address") != Xextensions.end())
{
if (!libGL)
{
libGL = dlopen("libGL.so", RTLD_LAZY|RTLD_GLOBAL);
if (libGL)
bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) (dlsym(libGL, "glXGetProcAddressARB"));
else
std::cout << "Error: " << dlerror() << std::endl;
// dlclose(libGL);
if (!bglGetProcAddress)
bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) _getProcAddress;
// --
if(!bglGetProcAddress)
std::cout << "Error: unable to find _getProcAddress in libGL" << std::endl;
}
}
}
static void bglDeallocEntryPoints (void) {}
#elif defined(WIN32)
static void bglInitEntryPoints (void) {}
static void bglDeallocEntryPoints (void) {}
#define bglGetProcAddress(entry) wglGetProcAddress((LPCSTR) entry)
#else /* Unknown Platform - disable extensions */
static void bglInitEntryPoints (void) {}
static void bglDeallocEntryPoints (void) {}
static void *bglGetProcAddress(const GLubyte* entry)
{
/* No Extensions! */
return NULL;
}
#endif /* End Platform Specific */
/* -----------------------------------------------------------------------------
GL Extension Manager.
*/
/* Bit array of available extensions */
static std::bitset<bgl::NUM_EXTENSIONS> enabled_extensions;
static std::vector<STR_String> extensions;
static int m_debug;
static void LinkExtensions();
static void EnableExtension(bgl::ExtensionName name)
{
unsigned int num = (unsigned int) name;
if (num < bgl::NUM_EXTENSIONS)
enabled_extensions.set(num);
}
static bool QueryExtension(STR_String extension_name)
{
return std::find(extensions.begin(), extensions.end(), extension_name) != extensions.end();
}
namespace bgl
{
void InitExtensions(int debug)
{
m_debug = debug;
bglInitEntryPoints (); //init bundle
EnableExtension(_BGL_TEST);
LinkExtensions();
bglDeallocEntryPoints();
}
bool QueryExtension(ExtensionName name)
{
unsigned int num = (unsigned int) name;
if (num < NUM_EXTENSIONS)
return enabled_extensions[num];
return false;
}
bool QueryVersion(int major, int minor)
{
static int gl_major = 0;
static int gl_minor = 0;
if (gl_major == 0)
void InitExtensions(bool debug)
{
const char *gl_version_str = (const char *) glGetString(GL_VERSION);
if (!gl_version_str)
return false;
STR_String gl_version = STR_String(gl_version_str);
int i = gl_version.Find('.');
gl_major = gl_version.Left(i).ToInt();
gl_minor = gl_version.Mid(i+1, gl_version.FindOneOf(". ", i+1) - i - 1).ToInt();
static bool doQueryVersion = m_debug;
if (doQueryVersion)
{
doQueryVersion = false;
std::cout << "GL_VERSION: " << gl_major << "." << gl_minor << " (" << gl_version << ")" << std::endl;
}
}
if (gl_major > major)
return true;
if (gl_major == major && gl_minor >= minor)
return true;
static bool firsttime = true;
return false;
}
if(firsttime) {
firsttime = false;
/*******************************************************************************
1. Extension function entry points go here
Need to #ifdef (compile time test for extension)
Add null functions if appropriate
Some extensions have been incorporated into the core GL, eg Multitexture was
added in GL v1.1. If Blender calls one of these functions before they are
linked, it will crash. Even worse, if Blender *indirectly* calls one of these
functions, (ie the GL implementation calls them itself) Blender will crash.
We fix this by adding them to the bgl namespace - the functions are now
private to the gameengine. Code can transparently use extensions by adding:
using namespace bgl;
to their source. Cunning like a weasel.
******************************************************************************/
#if defined(PFNGLPNTRIANGLESIATIPROC)
PFNGLPNTRIANGLESIATIPROC glPNTrianglesiATI;
PFNGLPNTRIANGLESFATIPROC glPNTrianglesfATI;
#endif
BL_EXTInfo RAS_EXT_support;
#ifdef GL_ARB_multitexture
int max_texture_units = 2;
PFNGLACTIVETEXTUREARBPROC blActiveTextureARB;
PFNGLCLIENTACTIVETEXTUREARBPROC blClientActiveTextureARB;
PFNGLMULTITEXCOORD1DARBPROC blMultiTexCoord1dARB;
PFNGLMULTITEXCOORD1DVARBPROC blMultiTexCoord1dvARB;
PFNGLMULTITEXCOORD1FARBPROC blMultiTexCoord1fARB;
PFNGLMULTITEXCOORD1FVARBPROC blMultiTexCoord1fvARB;
PFNGLMULTITEXCOORD1IARBPROC blMultiTexCoord1iARB;
PFNGLMULTITEXCOORD1IVARBPROC blMultiTexCoord1ivARB;
PFNGLMULTITEXCOORD1SARBPROC blMultiTexCoord1sARB;
PFNGLMULTITEXCOORD1SVARBPROC blMultiTexCoord1svARB;
PFNGLMULTITEXCOORD2DARBPROC blMultiTexCoord2dARB;
PFNGLMULTITEXCOORD2DVARBPROC blMultiTexCoord2dvARB;
PFNGLMULTITEXCOORD2FARBPROC blMultiTexCoord2fARB;
PFNGLMULTITEXCOORD2FVARBPROC blMultiTexCoord2fvARB;
PFNGLMULTITEXCOORD2IARBPROC blMultiTexCoord2iARB;
PFNGLMULTITEXCOORD2IVARBPROC blMultiTexCoord2ivARB;
PFNGLMULTITEXCOORD2SARBPROC blMultiTexCoord2sARB;
PFNGLMULTITEXCOORD2SVARBPROC blMultiTexCoord2svARB;
PFNGLMULTITEXCOORD3DARBPROC blMultiTexCoord3dARB;
PFNGLMULTITEXCOORD3DVARBPROC blMultiTexCoord3dvARB;
PFNGLMULTITEXCOORD3FARBPROC blMultiTexCoord3fARB;
PFNGLMULTITEXCOORD3FVARBPROC blMultiTexCoord3fvARB;
PFNGLMULTITEXCOORD3IARBPROC blMultiTexCoord3iARB;
PFNGLMULTITEXCOORD3IVARBPROC blMultiTexCoord3ivARB;
PFNGLMULTITEXCOORD3SARBPROC blMultiTexCoord3sARB;
PFNGLMULTITEXCOORD3SVARBPROC blMultiTexCoord3svARB;
PFNGLMULTITEXCOORD4DARBPROC blMultiTexCoord4dARB;
PFNGLMULTITEXCOORD4DVARBPROC blMultiTexCoord4dvARB;
PFNGLMULTITEXCOORD4FARBPROC blMultiTexCoord4fARB;
PFNGLMULTITEXCOORD4FVARBPROC blMultiTexCoord4fvARB;
PFNGLMULTITEXCOORD4IARBPROC blMultiTexCoord4iARB;
PFNGLMULTITEXCOORD4IVARBPROC blMultiTexCoord4ivARB;
PFNGLMULTITEXCOORD4SARBPROC blMultiTexCoord4sARB;
PFNGLMULTITEXCOORD4SVARBPROC blMultiTexCoord4svARB;
#endif
#ifdef GL_ARB_shader_objects
PFNGLDELETEOBJECTARBPROC blDeleteObjectARB;
PFNGLGETHANDLEARBPROC blGetHandleARB;
PFNGLDETACHOBJECTARBPROC blDetachObjectARB;
PFNGLCREATESHADEROBJECTARBPROC blCreateShaderObjectARB;
PFNGLSHADERSOURCEARBPROC blShaderSourceARB;
PFNGLCOMPILESHADERARBPROC blCompileShaderARB;
PFNGLCREATEPROGRAMOBJECTARBPROC blCreateProgramObjectARB;
PFNGLATTACHOBJECTARBPROC blAttachObjectARB;
PFNGLLINKPROGRAMARBPROC blLinkProgramARB;
PFNGLUSEPROGRAMOBJECTARBPROC blUseProgramObjectARB;
PFNGLVALIDATEPROGRAMARBPROC blValidateProgramARB;
PFNGLUNIFORM1FARBPROC blUniform1fARB;
PFNGLUNIFORM2FARBPROC blUniform2fARB;
PFNGLUNIFORM3FARBPROC blUniform3fARB;
PFNGLUNIFORM4FARBPROC blUniform4fARB;
PFNGLUNIFORM1IARBPROC blUniform1iARB;
PFNGLUNIFORM2IARBPROC blUniform2iARB;
PFNGLUNIFORM3IARBPROC blUniform3iARB;
PFNGLUNIFORM4IARBPROC blUniform4iARB;
PFNGLUNIFORM1FVARBPROC blUniform1fvARB;
PFNGLUNIFORM2FVARBPROC blUniform2fvARB;
PFNGLUNIFORM3FVARBPROC blUniform3fvARB;
PFNGLUNIFORM4FVARBPROC blUniform4fvARB;
PFNGLUNIFORM1IVARBPROC blUniform1ivARB;
PFNGLUNIFORM2IVARBPROC blUniform2ivARB;
PFNGLUNIFORM3IVARBPROC blUniform3ivARB;
PFNGLUNIFORM4IVARBPROC blUniform4ivARB;
PFNGLUNIFORMMATRIX2FVARBPROC blUniformMatrix2fvARB;
PFNGLUNIFORMMATRIX3FVARBPROC blUniformMatrix3fvARB;
PFNGLUNIFORMMATRIX4FVARBPROC blUniformMatrix4fvARB;
PFNGLGETOBJECTPARAMETERFVARBPROC blGetObjectParameterfvARB;
PFNGLGETOBJECTPARAMETERIVARBPROC blGetObjectParameterivARB;
PFNGLGETINFOLOGARBPROC blGetInfoLogARB;
PFNGLGETATTACHEDOBJECTSARBPROC blGetAttachedObjectsARB;
PFNGLGETUNIFORMLOCATIONARBPROC blGetUniformLocationARB;
PFNGLGETACTIVEUNIFORMARBPROC blGetActiveUniformARB;
PFNGLGETUNIFORMFVARBPROC blGetUniformfvARB;
PFNGLGETUNIFORMIVARBPROC blGetUniformivARB;
PFNGLGETSHADERSOURCEARBPROC blGetShaderSourceARB;
#endif
#ifdef GL_ARB_vertex_shader
PFNGLBINDATTRIBLOCATIONARBPROC blBindAttribLocationARB;
PFNGLGETACTIVEATTRIBARBPROC blGetActiveAttribARB;
PFNGLGETATTRIBLOCATIONARBPROC blGetAttribLocationARB;
#endif
#ifdef GL_ARB_vertex_program
PFNGLVERTEXATTRIB1FARBPROC blVertexAttrib1fARB;
PFNGLVERTEXATTRIB1FVARBPROC blVertexAttrib1fvARB;
PFNGLVERTEXATTRIB2FARBPROC blVertexAttrib2fARB;
PFNGLVERTEXATTRIB2FVARBPROC blVertexAttrib2fvARB;
PFNGLVERTEXATTRIB3FARBPROC blVertexAttrib3fARB;
PFNGLVERTEXATTRIB3FVARBPROC blVertexAttrib3fvARB;
PFNGLVERTEXATTRIB4FARBPROC blVertexAttrib4fARB;
PFNGLVERTEXATTRIB4FVARBPROC blVertexAttrib4fvARB;
PFNGLGETPROGRAMSTRINGARBPROC blGetProgramStringARB;
PFNGLGETVERTEXATTRIBDVARBPROC blGetVertexAttribdvARB;
PFNGLGETVERTEXATTRIBFVARBPROC blGetVertexAttribfvARB;
PFNGLGETVERTEXATTRIBIVARBPROC blGetVertexAttribivARB;
#endif
/*
#ifdef GL_EXT_compiled_vertex_array
PFNGLLOCKARRAYSEXTPROC blLockArraysEXT;
PFNGLUNLOCKARRAYSEXTPROC blUnlockArraysEXT;
#endif
*/
} // namespace bgl
using namespace bgl;
/*******************************************************************************
2. Query extension functions here
Need to #ifdef (compile time test for extension)
Use QueryExtension("GL_EXT_name") to test at runtime.
Use bglGetProcAddress to find entry point
Use EnableExtension(_GL_EXT_...) to allow Blender to use the extension.
******************************************************************************/
static void LinkExtensions()
{
static bool doDebugMessages = m_debug;
extensions = STR_String((const char *) glGetString(GL_EXTENSIONS)).Explode(' ');
RAS_EXT_support = BL_EXTInfo();
#if defined(PFNGLPNTRIANGLESIATIPROC)
if (QueryExtension("GL_ATI_pn_triangles"))
{
glPNTrianglesiATI = reinterpret_cast<PFNGLPNTRIANGLESIATIPROC>(bglGetProcAddress((const GLubyte *) "glPNTrianglesiATI"));
glPNTrianglesfATI = reinterpret_cast<PFNGLPNTRIANGLESFATIPROC>(bglGetProcAddress((const GLubyte *) "glPNTrianglesfATI"));
if (glPNTrianglesiATI && glPNTrianglesfATI) {
EnableExtension(_GL_ATI_pn_triangles);
if (doDebugMessages)
std::cout << "Enabled GL_ATI_pn_triangles" << std::endl;
} else {
std::cout << "ERROR: GL_ATI_pn_triangles implementation is broken!" << std::endl;
}
}
#endif
#ifdef GL_ARB_texture_env_combine
if (QueryExtension("GL_ARB_texture_env_combine"))
{
EnableExtension(_GL_ARB_texture_env_combine);
RAS_EXT_support._ARB_texture_env_combine = 1;
if (doDebugMessages)
{
std::cout << "Detected GL_ARB_texture_env_combine" << std::endl;
}
}
#endif
#ifdef GL_ARB_texture_cube_map
if (QueryExtension("GL_ARB_texture_cube_map"))
{
EnableExtension(_GL_ARB_texture_cube_map);
RAS_EXT_support._ARB_texture_cube_map = 1;
if (doDebugMessages)
std::cout << "Detected GL_ARB_texture_cube_map" << std::endl;
}
#endif
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if (QueryExtension("GL_ARB_multitexture")) {
bgl::blActiveTextureARB = reinterpret_cast<PFNGLACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glActiveTextureARB"));
bgl::blClientActiveTextureARB = reinterpret_cast<PFNGLCLIENTACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glClientActiveTextureARB"));
bgl::blMultiTexCoord1dARB = reinterpret_cast<PFNGLMULTITEXCOORD1DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dARB"));
bgl::blMultiTexCoord1dvARB = reinterpret_cast<PFNGLMULTITEXCOORD1DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dvARB"));
bgl::blMultiTexCoord1fARB = reinterpret_cast<PFNGLMULTITEXCOORD1FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fARB"));
bgl::blMultiTexCoord1fvARB = reinterpret_cast<PFNGLMULTITEXCOORD1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fvARB"));
bgl::blMultiTexCoord1iARB = reinterpret_cast<PFNGLMULTITEXCOORD1IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1iARB"));
bgl::blMultiTexCoord1ivARB = reinterpret_cast<PFNGLMULTITEXCOORD1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1ivARB"));
bgl::blMultiTexCoord1sARB = reinterpret_cast<PFNGLMULTITEXCOORD1SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1sARB"));
bgl::blMultiTexCoord1svARB = reinterpret_cast<PFNGLMULTITEXCOORD1SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1svARB"));
bgl::blMultiTexCoord2dARB = reinterpret_cast<PFNGLMULTITEXCOORD2DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dARB"));
bgl::blMultiTexCoord2dvARB = reinterpret_cast<PFNGLMULTITEXCOORD2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dvARB"));
bgl::blMultiTexCoord2fARB = reinterpret_cast<PFNGLMULTITEXCOORD2FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fARB"));
bgl::blMultiTexCoord2fvARB = reinterpret_cast<PFNGLMULTITEXCOORD2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fvARB"));
bgl::blMultiTexCoord2iARB = reinterpret_cast<PFNGLMULTITEXCOORD2IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2iARB"));
bgl::blMultiTexCoord2ivARB = reinterpret_cast<PFNGLMULTITEXCOORD2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2ivARB"));
bgl::blMultiTexCoord2sARB = reinterpret_cast<PFNGLMULTITEXCOORD2SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2sARB"));
bgl::blMultiTexCoord2svARB = reinterpret_cast<PFNGLMULTITEXCOORD2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2svARB"));
bgl::blMultiTexCoord3dARB = reinterpret_cast<PFNGLMULTITEXCOORD3DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dARB"));
bgl::blMultiTexCoord3dvARB = reinterpret_cast<PFNGLMULTITEXCOORD3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dvARB"));
bgl::blMultiTexCoord3fARB = reinterpret_cast<PFNGLMULTITEXCOORD3FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fARB"));
bgl::blMultiTexCoord3fvARB = reinterpret_cast<PFNGLMULTITEXCOORD3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fvARB"));
bgl::blMultiTexCoord3iARB = reinterpret_cast<PFNGLMULTITEXCOORD3IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3iARB"));
bgl::blMultiTexCoord3ivARB = reinterpret_cast<PFNGLMULTITEXCOORD3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3ivARB"));
bgl::blMultiTexCoord3sARB = reinterpret_cast<PFNGLMULTITEXCOORD3SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3sARB"));
bgl::blMultiTexCoord3svARB = reinterpret_cast<PFNGLMULTITEXCOORD3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3svARB"));
bgl::blMultiTexCoord4dARB = reinterpret_cast<PFNGLMULTITEXCOORD4DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dARB"));
bgl::blMultiTexCoord4dvARB = reinterpret_cast<PFNGLMULTITEXCOORD4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dvARB"));
bgl::blMultiTexCoord4fARB = reinterpret_cast<PFNGLMULTITEXCOORD4FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fARB"));
bgl::blMultiTexCoord4fvARB = reinterpret_cast<PFNGLMULTITEXCOORD4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fvARB"));
bgl::blMultiTexCoord4iARB = reinterpret_cast<PFNGLMULTITEXCOORD4IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4iARB"));
bgl::blMultiTexCoord4ivARB = reinterpret_cast<PFNGLMULTITEXCOORD4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4ivARB"));
bgl::blMultiTexCoord4sARB = reinterpret_cast<PFNGLMULTITEXCOORD4SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4sARB"));
bgl::blMultiTexCoord4svARB = reinterpret_cast<PFNGLMULTITEXCOORD4SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4svARB"));
if (bgl::blActiveTextureARB && bgl::blClientActiveTextureARB && bgl::blMultiTexCoord1dARB && bgl::blMultiTexCoord1dvARB && bgl::blMultiTexCoord1fARB && bgl::blMultiTexCoord1fvARB && bgl::blMultiTexCoord1iARB && bgl::blMultiTexCoord1ivARB && bgl::blMultiTexCoord1sARB && bgl::blMultiTexCoord1svARB && bgl::blMultiTexCoord2dARB && bgl::blMultiTexCoord2dvARB && bgl::blMultiTexCoord2fARB && bgl::blMultiTexCoord2fvARB && bgl::blMultiTexCoord2iARB && bgl::blMultiTexCoord2ivARB && bgl::blMultiTexCoord2sARB && bgl::blMultiTexCoord2svARB && bgl::blMultiTexCoord3dARB && bgl::blMultiTexCoord3dvARB && bgl::blMultiTexCoord3fARB && bgl::blMultiTexCoord3fvARB && bgl::blMultiTexCoord3iARB && bgl::blMultiTexCoord3ivARB && bgl::blMultiTexCoord3sARB && bgl::blMultiTexCoord3svARB && bgl::blMultiTexCoord4dARB && bgl::blMultiTexCoord4dvARB && bgl::blMultiTexCoord4fARB && bgl::blMultiTexCoord4fvARB && bgl::blMultiTexCoord4iARB && bgl::blMultiTexCoord4ivARB && bgl::blMultiTexCoord4sARB && bgl::blMultiTexCoord4svARB) {
EnableExtension(_GL_ARB_multitexture);
RAS_EXT_support._ARB_multitexture = 1;
if (doDebugMessages)
std::cout << "Enabled GL_ARB_multitexture" << std::endl;
} else {
std::cout << "ERROR: GL_ARB_multitexture implementation is broken!" << std::endl;
if(debug) {
if(GLEW_ATI_pn_triangles)
std::cout << "Enabled GL_ATI_pn_triangles" << std::endl;
if(GLEW_ARB_texture_env_combine)
std::cout << "Detected GL_ARB_texture_env_combine" << std::endl;
if(GLEW_ARB_texture_cube_map)
std::cout << "Detected GL_ARB_texture_cube_map" << std::endl;
if(GLEW_ARB_multitexture)
std::cout << "Detected GL_ARB_multitexture" << std::endl;
if(GLEW_ARB_shader_objects)
std::cout << "Detected GL_ARB_shader_objects" << std::endl;
if(GLEW_ARB_vertex_shader)
std::cout << "Detected GL_ARB_vertex_shader" << std::endl;
if(GLEW_ARB_fragment_shader)
std::cout << "Detected GL_ARB_fragment_shader" << std::endl;
if(GLEW_ARB_vertex_program)
std::cout << "Detected GL_ARB_vertex_program" << std::endl;
if(GLEW_ARB_depth_texture)
std::cout << "Detected GL_ARB_depth_texture" << std::endl;
if(GLEW_EXT_separate_specular_color)
std::cout << "Detected GL_EXT_separate_specular_color" << std::endl;
}
}
}
#endif
#if GL_ARB_shader_objects
if (QueryExtension("GL_ARB_shader_objects"))
{
bgl::blDeleteObjectARB = reinterpret_cast<PFNGLDELETEOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB"));
bgl::blGetHandleARB = reinterpret_cast<PFNGLGETHANDLEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetHandleARB"));
bgl::blDetachObjectARB = reinterpret_cast<PFNGLDETACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDetachObjectARB"));
bgl::blCreateShaderObjectARB = reinterpret_cast<PFNGLCREATESHADEROBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB"));
bgl::blShaderSourceARB = reinterpret_cast<PFNGLSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glShaderSourceARB"));
bgl::blCompileShaderARB = reinterpret_cast<PFNGLCOMPILESHADERARBPROC>(bglGetProcAddress((const GLubyte *) "glCompileShaderARB"));
bgl::blCreateProgramObjectARB = reinterpret_cast<PFNGLCREATEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB"));
bgl::blAttachObjectARB = reinterpret_cast<PFNGLATTACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glAttachObjectARB"));
bgl::blLinkProgramARB = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glLinkProgramARB"));
bgl::blUseProgramObjectARB = reinterpret_cast<PFNGLUSEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB"));
bgl::blValidateProgramARB = reinterpret_cast<PFNGLVALIDATEPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glValidateProgramARB"));
bgl::blUniform1fARB = reinterpret_cast<PFNGLUNIFORM1FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fARB"));
bgl::blUniform2fARB = reinterpret_cast<PFNGLUNIFORM2FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fARB"));
bgl::blUniform3fARB = reinterpret_cast<PFNGLUNIFORM3FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fARB"));
bgl::blUniform4fARB = reinterpret_cast<PFNGLUNIFORM4FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fARB"));
bgl::blUniform1iARB = reinterpret_cast<PFNGLUNIFORM1IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1iARB"));
bgl::blUniform2iARB = reinterpret_cast<PFNGLUNIFORM2IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2iARB"));
bgl::blUniform3iARB = reinterpret_cast<PFNGLUNIFORM3IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3iARB"));
bgl::blUniform4iARB = reinterpret_cast<PFNGLUNIFORM4IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4iARB"));
bgl::blUniform1fvARB = reinterpret_cast<PFNGLUNIFORM1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fvARB"));
bgl::blUniform2fvARB = reinterpret_cast<PFNGLUNIFORM2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fvARB"));
bgl::blUniform3fvARB = reinterpret_cast<PFNGLUNIFORM3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fvARB"));
bgl::blUniform4fvARB = reinterpret_cast<PFNGLUNIFORM4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fvARB"));
bgl::blUniform1ivARB = reinterpret_cast<PFNGLUNIFORM1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1ivARB"));
bgl::blUniform2ivARB = reinterpret_cast<PFNGLUNIFORM2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2ivARB"));
bgl::blUniform3ivARB = reinterpret_cast<PFNGLUNIFORM3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3ivARB"));
bgl::blUniform4ivARB = reinterpret_cast<PFNGLUNIFORM4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4ivARB"));
bgl::blUniformMatrix2fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB"));
bgl::blUniformMatrix3fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB"));
bgl::blUniformMatrix4fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB"));
bgl::blGetObjectParameterfvARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB"));
bgl::blGetObjectParameterivARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB"));
bgl::blGetInfoLogARB = reinterpret_cast<PFNGLGETINFOLOGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB"));
bgl::blGetAttachedObjectsARB = reinterpret_cast<PFNGLGETATTACHEDOBJECTSARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB"));
bgl::blGetUniformLocationARB = reinterpret_cast<PFNGLGETUNIFORMLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB"));
bgl::blGetActiveUniformARB = reinterpret_cast<PFNGLGETACTIVEUNIFORMARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB"));
bgl::blGetUniformfvARB = reinterpret_cast<PFNGLGETUNIFORMFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB"));
bgl::blGetUniformivARB = reinterpret_cast<PFNGLGETUNIFORMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformivARB"));
bgl::blGetShaderSourceARB = reinterpret_cast<PFNGLGETSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetShaderSourceARB"));
if (bgl::blDeleteObjectARB && bgl::blGetHandleARB && bgl::blDetachObjectARB && bgl::blCreateShaderObjectARB && bgl::blShaderSourceARB && bgl::blCompileShaderARB && bgl::blCreateProgramObjectARB && bgl::blAttachObjectARB && bgl::blLinkProgramARB && bgl::blUseProgramObjectARB && bgl::blValidateProgramARB && bgl::blUniform1fARB && bgl::blUniform2fARB && bgl::blUniform3fARB && bgl::blUniform4fARB && bgl::blUniform1iARB && bgl::blUniform2iARB && bgl::blUniform3iARB && bgl::blUniform4iARB && bgl::blUniform1fvARB && bgl::blUniform2fvARB && bgl::blUniform3fvARB && bgl::blUniform4fvARB && bgl::blUniform1ivARB && bgl::blUniform2ivARB && bgl::blUniform3ivARB && bgl::blUniform4ivARB && bgl::blUniformMatrix2fvARB && bgl::blUniformMatrix3fvARB && bgl::blUniformMatrix4fvARB && bgl::blGetObjectParameterfvARB && bgl::blGetObjectParameterivARB && bgl::blGetInfoLogARB && bgl::blGetAttachedObjectsARB && bgl::blGetUniformLocationARB && bgl::blGetActiveUniformARB && bgl::blGetUniformfvARB && bgl::blGetUniformivARB && bgl::blGetShaderSourceARB) {
EnableExtension(_GL_ARB_shader_objects);
RAS_EXT_support._ARB_shader_objects =1;
if (doDebugMessages)
std::cout << "Enabled GL_ARB_shader_objects" << std::endl;
} else {
std::cout << "ERROR: GL_ARB_shader_objects implementation is broken!" << std::endl;
}
}
#endif
#if GL_ARB_vertex_shader
if (QueryExtension("GL_ARB_vertex_shader"))
{
bgl::blBindAttribLocationARB = reinterpret_cast<PFNGLBINDATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB"));
bgl::blGetActiveAttribARB = reinterpret_cast<PFNGLGETACTIVEATTRIBARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB"));
bgl::blGetAttribLocationARB = reinterpret_cast<PFNGLGETATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB"));
if (bgl::blBindAttribLocationARB && bgl::blGetActiveAttribARB && bgl::blGetAttribLocationARB) {
EnableExtension(_GL_ARB_vertex_shader);
RAS_EXT_support._ARB_vertex_shader = 1;
if (doDebugMessages)
std::cout << "Enabled GL_ARB_vertex_shader" << std::endl;
} else {
std::cout << "ERROR: GL_ARB_vertex_shader implementation is broken!" << std::endl;
}
}
#endif
#ifdef GL_ARB_fragment_shader
if (QueryExtension("GL_ARB_fragment_shader"))
{
EnableExtension(_GL_ARB_fragment_shader);
RAS_EXT_support._ARB_fragment_shader = 1;
if (doDebugMessages)
std::cout << "Detected GL_ARB_fragment_shader" << std::endl;
}
#endif
#if defined(GL_ARB_vertex_program)
if (QueryExtension("GL_ARB_vertex_program"))
{
bgl::blVertexAttrib1fARB = reinterpret_cast<PFNGLVERTEXATTRIB1FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fARB"));
bgl::blVertexAttrib1fvARB = reinterpret_cast<PFNGLVERTEXATTRIB1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fvARB"));
bgl::blVertexAttrib2fARB = reinterpret_cast<PFNGLVERTEXATTRIB2FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fARB"));
bgl::blVertexAttrib2fvARB = reinterpret_cast<PFNGLVERTEXATTRIB2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fvARB"));
bgl::blVertexAttrib3fARB = reinterpret_cast<PFNGLVERTEXATTRIB3FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fARB"));
bgl::blVertexAttrib3fvARB = reinterpret_cast<PFNGLVERTEXATTRIB3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fvARB"));
bgl::blVertexAttrib4fARB = reinterpret_cast<PFNGLVERTEXATTRIB4FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fARB"));
bgl::blVertexAttrib4fvARB = reinterpret_cast<PFNGLVERTEXATTRIB4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fvARB"));
bgl::blGetVertexAttribdvARB = reinterpret_cast<PFNGLGETVERTEXATTRIBDVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribdvARB"));
bgl::blGetVertexAttribfvARB = reinterpret_cast<PFNGLGETVERTEXATTRIBFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribfvARB"));
bgl::blGetVertexAttribivARB = reinterpret_cast<PFNGLGETVERTEXATTRIBIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribivARB"));
if (bgl::blVertexAttrib1fARB && bgl::blVertexAttrib1fvARB && bgl::blVertexAttrib2fARB && bgl::blVertexAttrib2fvARB && bgl::blVertexAttrib3fARB && bgl::blVertexAttrib3fvARB && bgl::blGetVertexAttribdvARB) {
EnableExtension(_GL_ARB_vertex_program);
RAS_EXT_support._ARB_vertex_program = 1;
if (doDebugMessages)
std::cout << "Enabled GL_ARB_vertex_program" << std::endl;
} else {
std::cout << "ERROR: GL_ARB_vertex_program implementation is broken!" << std::endl;
}
}
#endif
#ifdef GL_ARB_depth_texture
if (QueryExtension("GL_ARB_depth_texture"))
{
EnableExtension(_GL_ARB_depth_texture);
RAS_EXT_support._ARB_depth_texture = 1;
if (doDebugMessages)
{
std::cout << "Detected GL_ARB_depth_texture" << std::endl;
}
}
#endif
/*
#ifdef GL_EXT_compiled_vertex_array
if (QueryExtension("GL_EXT_compiled_vertex_array"))
{
blLockArraysEXT = reinterpret_cast<PFNGLLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glLockArraysEXT"));
blUnlockArraysEXT = reinterpret_cast<PFNGLUNLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT"));
if (blLockArraysEXT && blUnlockArraysEXT) {
EnableExtension(_GL_EXT_compiled_vertex_array);
RAS_EXT_support._EXT_compiled_vertex_array = 1;
if (doDebugMessages)
std::cout << "Enabled GL_EXT_compiled_vertex_array" << std::endl;
} else {
std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl;
}
}
#endif
*/
if (QueryExtension("GL_EXT_separate_specular_color"))
{
EnableExtension(_GL_EXT_separate_specular_color);
if (doDebugMessages)
std::cout << "Detected GL_EXT_separate_specular_color" << std::endl;
}
doDebugMessages = false;
}
} // namespace bgl

507
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h
View File

@ -29,513 +29,14 @@
#ifndef __RAS_GLEXTENSIONMANAGER_H__
#define __RAS_GLEXTENSIONMANAGER_H__
#include "GL/glew.h"
#ifdef WIN32
# include <windows.h>
# include <GL/gl.h>
/* Note: this used to have a lot more code, but now extension handling
* is done by GLEW, so it does mostly debug stuff */
#elif defined(__APPLE__)
# define GL_GLEXT_LEGACY 1
# include <OpenGL/gl.h>
# include <OpenGL/glu.h>
#else /* UNIX */
# define __glext_h_
# include <GL/gl.h>
# include <GL/glx.h>
# undef GL_ARB_multitexture // (ubuntu)
# undef __glext_h_
#endif
#ifdef WITH_GLEXT
#ifdef WIN32
# include <GL/glext.h>
#elif defined(__APPLE__)
# include "mac_compat_glext.h"
# include <OpenGL/glext.h>
#else
# include <GL/glext.h>
#endif
#endif
#ifdef __sgi
# undef GL_ARB_vertex_program
#endif
#include "EXT_separate_specular_color.h"
#include "ARB_multitexture.h"
namespace bgl
{
/**
* This is a list of all registered OpenGL extensions.
* It is available from:
* http://oss.sgi.com/projects/ogl-sample/registry/
*/
typedef enum {
/* ARB Extensions */
_GL_ARB_imaging,
_GL_ARB_multitexture ,
_GLX_ARB_get_proc_address ,
_GL_ARB_transpose_matrix ,
_WGL_ARB_buffer_region ,
_GL_ARB_multisample ,
_GL_ARB_texture_env_add ,
_GL_ARB_texture_cube_map ,
_WGL_ARB_extensions_string ,
_WGL_ARB_pixel_format ,
_WGL_ARB_make_current_read ,
_WGL_ARB_pbuffer ,
_GL_ARB_texture_compression ,
_GL_ARB_texture_border_clamp ,
_GL_ARB_point_parameters ,
_GL_ARB_vertex_blend ,
_GL_ARB_matrix_palette ,
_GL_ARB_texture_env_combine ,
_GL_ARB_texture_env_crossbar ,
_GL_ARB_texture_env_dot3 ,
_WGL_ARB_render_texture ,
_GL_ARB_texture_mirrored_repeat ,
_GL_ARB_depth_texture ,
_GL_ARB_shadow ,
_GL_ARB_shadow_ambient ,
_GL_ARB_window_pos ,
_GL_ARB_vertex_program ,
_GL_ARB_fragment_program ,
_GL_ARB_vertex_buffer_object ,
_GL_ARB_occlusion_query ,
_GL_ARB_shader_objects ,
_GL_ARB_vertex_shader ,
_GL_ARB_fragment_shader ,
_GL_ARB_shading_language_100 ,
_GL_ARB_texture_non_power_of_two ,
_GL_ARB_point_sprite ,
_GL_ARB_fragment_program_shadow ,
/* Non ARB Extensions */
_GL_EXT_abgr ,
_GL_EXT_blend_color ,
_GL_EXT_polygon_offset ,
_GL_EXT_texture ,
_GL_EXT_texture3D ,
_GL_SGIS_texture_filter4 ,
_GL_EXT_subtexture ,
_GL_EXT_copy_texture ,
_GL_EXT_histogram ,
_GL_EXT_convolution ,
_GL_SGI_color_matrix ,
_GL_SGI_color_table ,
_GL_SGIS_pixel_texture ,
_GL_SGIS_texture4D ,
_GL_SGI_texture_color_table ,
_GL_EXT_cmyka ,
_GL_EXT_texture_object ,
_GL_SGIS_detail_texture ,
_GL_SGIS_sharpen_texture ,
_GL_EXT_packed_pixels ,
_GL_SGIS_texture_lod ,
_GL_SGIS_multisample ,
_GL_EXT_rescale_normal ,
_GLX_EXT_visual_info ,
_GL_EXT_vertex_array ,
_GL_EXT_misc_attribute ,
_GL_SGIS_generate_mipmap ,
_GL_SGIX_clipmap ,
_GL_SGIX_shadow ,
_GL_SGIS_texture_edge_clamp ,
_GL_SGIS_texture_border_clamp ,
_GL_EXT_blend_minmax ,
_GL_EXT_blend_subtract ,
_GL_EXT_blend_logic_op ,
_GLX_SGI_swap_control ,
_GLX_SGI_video_sync ,
_GLX_SGI_make_current_read ,
_GLX_SGIX_video_source ,
_GLX_EXT_visual_rating ,
_GL_SGIX_interlace ,
_GLX_EXT_import_context ,
_GLX_SGIX_fbconfig ,
_GLX_SGIX_pbuffer ,
_GL_SGIS_texture_select ,
_GL_SGIX_sprite ,
_GL_SGIX_texture_multi_buffer ,
_GL_EXT_point_parameters ,
_GL_SGIX_instruments ,
_GL_SGIX_texture_scale_bias ,
_GL_SGIX_framezoom ,
_GL_SGIX_tag_sample_buffer ,
_GL_SGIX_reference_plane ,
_GL_SGIX_flush_raster ,
_GLX_SGI_cushion ,
_GL_SGIX_depth_texture ,
_GL_SGIS_fog_function ,
_GL_SGIX_fog_offset ,
_GL_HP_image_transform ,
_GL_HP_convolution_border_modes ,
_GL_SGIX_texture_add_env ,
_GL_EXT_color_subtable ,
_GLU_EXT_object_space_tess ,
_GL_PGI_vertex_hints ,
_GL_PGI_misc_hints ,
_GL_EXT_paletted_texture ,
_GL_EXT_clip_volume_hint ,
_GL_SGIX_list_priority ,
_GL_SGIX_ir_instrument1 ,
_GLX_SGIX_video_resize ,
_GL_SGIX_texture_lod_bias ,
_GLU_SGI_filter4_parameters ,
_GLX_SGIX_dm_buffer ,
_GL_SGIX_shadow_ambient ,
_GLX_SGIX_swap_group ,
_GLX_SGIX_swap_barrier ,
_GL_EXT_index_texture ,
_GL_EXT_index_material ,
_GL_EXT_index_func ,
_GL_EXT_index_array_formats ,
_GL_EXT_compiled_vertex_array ,
_GL_EXT_cull_vertex ,
_GLU_EXT_nurbs_tessellator ,
_GL_SGIX_ycrcb ,
_GL_EXT_fragment_lighting ,
_GL_IBM_rasterpos_clip ,
_GL_HP_texture_lighting ,
_GL_EXT_draw_range_elements ,
_GL_WIN_phong_shading ,
_GL_WIN_specular_fog ,
_GLX_SGIS_color_range ,
_GL_EXT_light_texture ,
_GL_SGIX_blend_alpha_minmax ,
_GL_EXT_scene_marker ,
_GL_SGIX_pixel_texture_bits ,
_GL_EXT_bgra ,
_GL_SGIX_async ,
_GL_SGIX_async_pixel ,
_GL_SGIX_async_histogram ,
_GL_INTEL_texture_scissor ,
_GL_INTEL_parallel_arrays ,
_GL_HP_occlusion_test ,
_GL_EXT_pixel_transform ,
_GL_EXT_pixel_transform_color_table ,
_GL_EXT_shared_texture_palette ,
_GLX_SGIS_blended_overlay ,
_GL_EXT_separate_specular_color ,
_GL_EXT_secondary_color ,
_GL_EXT_texture_env ,
_GL_EXT_texture_perturb_normal ,
_GL_EXT_multi_draw_arrays ,
_GL_EXT_fog_coord ,
_GL_REND_screen_coordinates ,
_GL_EXT_coordinate_frame ,
_GL_EXT_texture_env_combine ,
_GL_APPLE_specular_vector ,
_GL_SGIX_pixel_texture ,
_GL_APPLE_transform_hint ,
_GL_SUNX_constant_data ,
_GL_SUN_global_alpha ,
_GL_SUN_triangle_list ,
_GL_SUN_vertex ,
_WGL_EXT_display_color_table ,
_WGL_EXT_extensions_string ,
_WGL_EXT_make_current_read ,
_WGL_EXT_pixel_format ,
_WGL_EXT_pbuffer ,
_WGL_EXT_swap_control ,
_GL_EXT_blend_func_separate ,
_GL_INGR_color_clamp ,
_GL_INGR_interlace_read ,
_GL_EXT_stencil_wrap ,
_WGL_EXT_depth_float ,
_GL_EXT_422_pixels ,
_GL_NV_texgen_reflection ,
_GL_SGIX_texture_range ,
_GL_SUN_convolution_border_modes ,
_GLX_SUN_get_transparent_index ,
_GL_EXT_texture_env_add ,
_GL_EXT_texture_lod_bias ,
_GL_EXT_texture_filter_anisotropic ,
_GL_EXT_vertex_weighting ,
_GL_NV_light_max_exponent ,
_GL_NV_vertex_array_range ,
_GL_NV_register_combiners ,
_GL_NV_fog_distance ,
_GL_NV_texgen_emboss ,
_GL_NV_blend_square ,
_GL_NV_texture_env_combine4 ,
_GL_MESA_resize_buffers ,
_GL_MESA_window_pos ,
_GL_EXT_texture_compression_s3tc ,
_GL_IBM_cull_vertex ,
_GL_IBM_multimode_draw_arrays ,
_GL_IBM_vertex_array_lists ,
_GL_3DFX_texture_compression_FXT1 ,
_GL_3DFX_multisample ,
_GL_3DFX_tbuffer ,
_WGL_EXT_multisample ,
_GL_SGIX_vertex_preclip ,
_GL_SGIX_resample ,
_GL_SGIS_texture_color_mask ,
_GLX_MESA_copy_sub_buffer ,
_GLX_MESA_pixmap_colormap ,
_GLX_MESA_release_buffers ,
_GLX_MESA_set_3dfx_mode ,
_GL_EXT_texture_env_dot3 ,
_GL_ATI_texture_mirror_once ,
_GL_NV_fence ,
_GL_IBM_static_data ,
_GL_IBM_texture_mirrored_repeat ,
_GL_NV_evaluators ,
_GL_NV_packed_depth_stencil ,
_GL_NV_register_combiners2 ,
_GL_NV_texture_compression_vtc ,
_GL_NV_texture_rectangle ,
_GL_NV_texture_shader ,
_GL_NV_texture_shader2 ,
_GL_NV_vertex_array_range2 ,
_GL_NV_vertex_program ,
_GLX_SGIX_visual_select_group ,
_GL_SGIX_texture_coordinate_clamp ,
_GLX_OML_swap_method ,
_GLX_OML_sync_control ,
_GL_OML_interlace ,
_GL_OML_subsample ,
_GL_OML_resample ,
_WGL_OML_sync_control ,
_GL_NV_copy_depth_to_color ,
_GL_ATI_envmap_bumpmap ,
_GL_ATI_fragment_shader ,
_GL_ATI_pn_triangles ,
_GL_ATI_vertex_array_object ,
_GL_EXT_vertex_shader ,
_GL_ATI_vertex_streams ,
_WGL_I3D_digital_video_control ,
_WGL_I3D_gamma ,
_WGL_I3D_genlock ,
_WGL_I3D_image_buffer ,
_WGL_I3D_swap_frame_lock ,
_WGL_I3D_swap_frame_usage ,
_GL_ATI_element_array ,
_GL_SUN_mesh_array ,
_GL_SUN_slice_accum ,
_GL_NV_multisample_filter_hint ,
_GL_NV_depth_clamp ,
_GL_NV_occlusion_query ,
_GL_NV_point_sprite ,
_WGL_NV_render_depth_texture ,
_WGL_NV_render_texture_rectangle ,
_GL_NV_texture_shader3 ,
_GL_NV_vertex_program1_1 ,
_GL_EXT_shadow_funcs ,
_GL_EXT_stencil_two_side ,
_GL_ATI_text_fragment_shader ,
_GL_APPLE_client_storage ,
_GL_APPLE_element_array ,
_GL_APPLE_fence ,
_GL_APPLE_vertex_array_object ,
_GL_APPLE_vertex_array_range ,
_GL_APPLE_ycbcr_422 ,
_GL_S3_s3tc ,
_GL_ATI_draw_buffers ,
_WGL_ATI_pixel_format_float ,
_GL_ATI_texture_env_combine3 ,
_GL_ATI_texture_float ,
_GL_NV_float_buffer ,
_GL_NV_fragment_program ,
_GL_NV_half_float ,
_GL_NV_pixel_data_range ,
_GL_NV_primitive_restart ,
_GL_NV_texture_expand_normal ,
_GL_NV_vertex_program2 ,
_GL_ATI_map_object_buffer ,
_GL_ATI_separate_stencil ,
_GL_ATI_vertex_attrib_array_object ,
_GL_OES_byte_coordinates ,
_GL_OES_fixed_point ,
_GL_OES_single_precision ,
_GL_OES_compressed_paletted_texture ,
_GL_OES_read_format ,
_GL_OES_query_matrix ,
_GL_EXT_depth_bounds_test ,
_GL_EXT_texture_mirror_clamp ,
_GL_EXT_blend_equation_separate ,
_GL_MESA_pack_invert ,
_GL_MESA_ycbcr_texture,
/* Finished */
_BGL_TEST,
NUM_EXTENSIONS
} ExtensionName;
/**
* Checks at runtime whether OpenGL supports the named extension.
* Returns true if OpenGL supports the given extension.
*
* @param name The extension name to check.
*/
bool QueryExtension(ExtensionName name);
/**
* Checks the OpenGL version.
* Returns true if OpenGL is at least the given version.
*
* @param major The major version required
* @param minor The minor version required
*/
bool QueryVersion(int major, int minor);
/**
* This will dynamically link all runtime supported extensions into
* the binary.
*
* @param debug Enable debug printing. This will print debugging info
* when extensions are loaded.
*/
void InitExtensions(int debug);
#if defined(PFNGLPNTRIANGLESIATIPROC)
extern PFNGLPNTRIANGLESIATIPROC blPNTrianglesiATI;
extern PFNGLPNTRIANGLESFATIPROC blPNTrianglesfATI;
#endif
// quick runtime checks
typedef struct BL_EXTInfo
{
BL_EXTInfo():
_ARB_multitexture(0),
_ARB_texture_env_combine(0),
_EXT_blend_color(0),
_ARB_texture_cube_map(0),
_ARB_shader_objects(0),
_ARB_vertex_shader(0),
_ARB_fragment_shader(0),
_EXT_texture3D(0),
_ARB_vertex_program(0),
_ARB_depth_texture(0),
_EXT_compiled_vertex_array(0)
{
//
}
bool _ARB_multitexture;
bool _ARB_texture_env_combine;
bool _EXT_blend_color;
bool _ARB_texture_cube_map;
bool _ARB_shader_objects;
bool _ARB_vertex_shader;
bool _ARB_fragment_shader;
bool _EXT_texture3D;
bool _ARB_vertex_program;
bool _ARB_depth_texture;
bool _EXT_compiled_vertex_array;
}BL_EXTInfo;
extern BL_EXTInfo RAS_EXT_support;
#ifdef GL_ARB_multitexture // defined in glext.h now...
extern int max_texture_units;
extern PFNGLACTIVETEXTUREARBPROC blActiveTextureARB;
extern PFNGLCLIENTACTIVETEXTUREARBPROC blClientActiveTextureARB;
extern PFNGLMULTITEXCOORD1DARBPROC blMultiTexCoord1dARB;
extern PFNGLMULTITEXCOORD1DVARBPROC blMultiTexCoord1dvARB;
extern PFNGLMULTITEXCOORD1FARBPROC blMultiTexCoord1fARB;
extern PFNGLMULTITEXCOORD1FVARBPROC blMultiTexCoord1fvARB;
extern PFNGLMULTITEXCOORD1IARBPROC blMultiTexCoord1iARB;
extern PFNGLMULTITEXCOORD1IVARBPROC blMultiTexCoord1ivARB;
extern PFNGLMULTITEXCOORD1SARBPROC blMultiTexCoord1sARB;
extern PFNGLMULTITEXCOORD1SVARBPROC blMultiTexCoord1svARB;
extern PFNGLMULTITEXCOORD2DARBPROC blMultiTexCoord2dARB;
extern PFNGLMULTITEXCOORD2DVARBPROC blMultiTexCoord2dvARB;
extern PFNGLMULTITEXCOORD2FARBPROC blMultiTexCoord2fARB;
extern PFNGLMULTITEXCOORD2FVARBPROC blMultiTexCoord2fvARB;
extern PFNGLMULTITEXCOORD2IARBPROC blMultiTexCoord2iARB;
extern PFNGLMULTITEXCOORD2IVARBPROC blMultiTexCoord2ivARB;
extern PFNGLMULTITEXCOORD2SARBPROC blMultiTexCoord2sARB;
extern PFNGLMULTITEXCOORD2SVARBPROC blMultiTexCoord2svARB;
extern PFNGLMULTITEXCOORD3DARBPROC blMultiTexCoord3dARB;
extern PFNGLMULTITEXCOORD3DVARBPROC blMultiTexCoord3dvARB;
extern PFNGLMULTITEXCOORD3FARBPROC blMultiTexCoord3fARB;
extern PFNGLMULTITEXCOORD3FVARBPROC blMultiTexCoord3fvARB;
extern PFNGLMULTITEXCOORD3IARBPROC blMultiTexCoord3iARB;
extern PFNGLMULTITEXCOORD3IVARBPROC blMultiTexCoord3ivARB;
extern PFNGLMULTITEXCOORD3SARBPROC blMultiTexCoord3sARB;
extern PFNGLMULTITEXCOORD3SVARBPROC blMultiTexCoord3svARB;
extern PFNGLMULTITEXCOORD4DARBPROC blMultiTexCoord4dARB;
extern PFNGLMULTITEXCOORD4DVARBPROC blMultiTexCoord4dvARB;
extern PFNGLMULTITEXCOORD4FARBPROC blMultiTexCoord4fARB;
extern PFNGLMULTITEXCOORD4FVARBPROC blMultiTexCoord4fvARB;
extern PFNGLMULTITEXCOORD4IARBPROC blMultiTexCoord4iARB;
extern PFNGLMULTITEXCOORD4IVARBPROC blMultiTexCoord4ivARB;
extern PFNGLMULTITEXCOORD4SARBPROC blMultiTexCoord4sARB;
extern PFNGLMULTITEXCOORD4SVARBPROC blMultiTexCoord4svARB;
#endif
#ifdef GL_ARB_shader_objects
extern PFNGLDELETEOBJECTARBPROC blDeleteObjectARB;
extern PFNGLGETHANDLEARBPROC blGetHandleARB;
extern PFNGLDETACHOBJECTARBPROC blDetachObjectARB;
extern PFNGLCREATESHADEROBJECTARBPROC blCreateShaderObjectARB;
extern PFNGLSHADERSOURCEARBPROC blShaderSourceARB;
extern PFNGLCOMPILESHADERARBPROC blCompileShaderARB;
extern PFNGLCREATEPROGRAMOBJECTARBPROC blCreateProgramObjectARB;
extern PFNGLATTACHOBJECTARBPROC blAttachObjectARB;
extern PFNGLLINKPROGRAMARBPROC blLinkProgramARB;
extern PFNGLUSEPROGRAMOBJECTARBPROC blUseProgramObjectARB;
extern PFNGLVALIDATEPROGRAMARBPROC blValidateProgramARB;
extern PFNGLUNIFORM1FARBPROC blUniform1fARB;
extern PFNGLUNIFORM2FARBPROC blUniform2fARB;
extern PFNGLUNIFORM3FARBPROC blUniform3fARB;
extern PFNGLUNIFORM4FARBPROC blUniform4fARB;
extern PFNGLUNIFORM1IARBPROC blUniform1iARB;
extern PFNGLUNIFORM2IARBPROC blUniform2iARB;
extern PFNGLUNIFORM3IARBPROC blUniform3iARB;
extern PFNGLUNIFORM4IARBPROC blUniform4iARB;
extern PFNGLUNIFORM1FVARBPROC blUniform1fvARB;
extern PFNGLUNIFORM2FVARBPROC blUniform2fvARB;
extern PFNGLUNIFORM3FVARBPROC blUniform3fvARB;
extern PFNGLUNIFORM4FVARBPROC blUniform4fvARB;
extern PFNGLUNIFORM1IVARBPROC blUniform1ivARB;
extern PFNGLUNIFORM2IVARBPROC blUniform2ivARB;
extern PFNGLUNIFORM3IVARBPROC blUniform3ivARB;
extern PFNGLUNIFORM4IVARBPROC blUniform4ivARB;
extern PFNGLUNIFORMMATRIX2FVARBPROC blUniformMatrix2fvARB;
extern PFNGLUNIFORMMATRIX3FVARBPROC blUniformMatrix3fvARB;
extern PFNGLUNIFORMMATRIX4FVARBPROC blUniformMatrix4fvARB;
extern PFNGLGETOBJECTPARAMETERFVARBPROC blGetObjectParameterfvARB;
extern PFNGLGETOBJECTPARAMETERIVARBPROC blGetObjectParameterivARB;
extern PFNGLGETINFOLOGARBPROC blGetInfoLogARB;
extern PFNGLGETATTACHEDOBJECTSARBPROC blGetAttachedObjectsARB;
extern PFNGLGETUNIFORMLOCATIONARBPROC blGetUniformLocationARB;
extern PFNGLGETACTIVEUNIFORMARBPROC blGetActiveUniformARB;
extern PFNGLGETUNIFORMFVARBPROC blGetUniformfvARB;
extern PFNGLGETUNIFORMIVARBPROC blGetUniformivARB;
extern PFNGLGETSHADERSOURCEARBPROC blGetShaderSourceARB;
#endif
#ifdef GL_ARB_vertex_shader
extern PFNGLBINDATTRIBLOCATIONARBPROC blBindAttribLocationARB;
extern PFNGLGETACTIVEATTRIBARBPROC blGetActiveAttribARB;
extern PFNGLGETATTRIBLOCATIONARBPROC blGetAttribLocationARB;
#endif
#ifdef GL_ARB_vertex_program
extern PFNGLVERTEXATTRIB1FARBPROC blVertexAttrib1fARB;
extern PFNGLVERTEXATTRIB1FVARBPROC blVertexAttrib1fvARB;
extern PFNGLVERTEXATTRIB2FARBPROC blVertexAttrib2fARB;
extern PFNGLVERTEXATTRIB2FVARBPROC blVertexAttrib2fvARB;
extern PFNGLVERTEXATTRIB3FARBPROC blVertexAttrib3fARB;
extern PFNGLVERTEXATTRIB3FVARBPROC blVertexAttrib3fvARB;
extern PFNGLVERTEXATTRIB4FARBPROC blVertexAttrib4fARB;
extern PFNGLVERTEXATTRIB4FVARBPROC blVertexAttrib4fvARB;
extern PFNGLGETPROGRAMSTRINGARBPROC blGetProgramStringARB;
extern PFNGLGETVERTEXATTRIBDVARBPROC blGetVertexAttribdvARB;
extern PFNGLGETVERTEXATTRIBFVARBPROC blGetVertexAttribfvARB;
extern PFNGLGETVERTEXATTRIBIVARBPROC blGetVertexAttribivARB;
#endif
/*
#ifdef GL_EXT_compiled_vertex_array
extern PFNGLLOCKARRAYSEXTPROC blLockArraysEXT;
extern PFNGLUNLOCKARRAYSEXTPROC blUnlockArraysEXT;
#endif
*/
void InitExtensions(bool debug);
} /* namespace bgl */
#endif /* __RAS_GLEXTENSIONMANAGER_H__ */

19
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
View File

@ -6,15 +6,10 @@
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "GL/glew.h"
#include "RAS_TexVert.h"
#include "RAS_GLExtensionManager.h"
#include "MT_assert.h"
//#ifndef NDEBUG
@ -27,8 +22,8 @@
RAS_ListSlot::RAS_ListSlot(RAS_ListRasterizer* rasty)
: KX_ListSlot(),
m_flag(LIST_MODIFY|LIST_CREATE),
m_list(0),
m_flag(LIST_MODIFY|LIST_CREATE),
m_rasty(rasty)
{
}
@ -176,7 +171,7 @@ void RAS_ListRasterizer::IndexPrimitives(
RAS_ListSlot* localSlot =0;
// useObjectColor(are we updating every frame?)
if(!useObjectColor) {
if(!useObjectColor && slot) {
localSlot = FindOrAdd(vertexarrays, slot);
localSlot->DrawList();
if(localSlot->End()) {
@ -203,7 +198,7 @@ void RAS_ListRasterizer::IndexPrimitives(
);
}
if(!useObjectColor) {
if(!useObjectColor && slot) {
localSlot->EndList();
*slot = localSlot;
}
@ -223,7 +218,7 @@ void RAS_ListRasterizer::IndexPrimitivesMulti(
RAS_ListSlot* localSlot =0;
// useObjectColor(are we updating every frame?)
if(!useObjectColor) {
if(!useObjectColor && slot) {
localSlot = FindOrAdd(vertexarrays, slot);
localSlot->DrawList();
@ -251,7 +246,7 @@ void RAS_ListRasterizer::IndexPrimitivesMulti(
);
}
if(!useObjectColor) {
if(!useObjectColor && slot) {
localSlot->EndList();
*slot = localSlot;
}

1071
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
View File

File diff suppressed because it is too large Load Diff

37
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
View File

@ -41,7 +41,8 @@ using namespace std;
#include "RAS_MaterialBucket.h"
#include "RAS_ICanvas.h"
#define RAS_MAX 3// match in BL_Material
#define RAS_MAX_TEXCO 3 // match in BL_Material
#define RAS_MAX_ATTRIB 16 // match in BL_BlenderShader
struct OglDebugLine
{
@ -94,8 +95,10 @@ class RAS_OpenGLRasterizer : public RAS_IRasterizer
protected:
int m_drawingmode;
TexCoGen m_texco[RAS_MAX];
bool m_useTang;
TexCoGen m_texco[RAS_MAX_TEXCO];
TexCoGen m_attrib[RAS_MAX_ATTRIB];
int m_texco_num;
int m_attrib_num;
/** Stores the caching information for the last material activated. */
RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
@ -153,16 +156,6 @@ public:
class KX_ListSlot** slot
);
virtual void IndexPrimitives_Ex(
const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
class RAS_IPolyMaterial* polymat,
class RAS_IRenderTools* rendertools,
bool useObjectColor,
const MT_Vector4& rgbacolor
);
virtual void IndexPrimitives_3DText(
const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
@ -183,15 +176,6 @@ public:
const MT_Vector4& rgbacolor,
class KX_ListSlot** slot);
virtual void IndexPrimitivesMulti_Ex(
const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
class RAS_IPolyMaterial* polymat,
class RAS_IRenderTools* rendertools,
bool useObjectColor,
const MT_Vector4& rgbacolor);
virtual void SetProjectionMatrix(MT_CmMatrix4x4 & mat);
virtual void SetProjectionMatrix(const MT_Matrix4x4 & mat);
@ -286,9 +270,12 @@ public:
std::vector <OglDebugLine> m_debugLines;
virtual void SetTexCoords(TexCoGen coords,int enabled);
virtual void SetAttrib(int type);
void TexCoord(const RAS_TexVert &tv, int unit);
virtual void SetTexCoordNum(int num);
virtual void SetAttribNum(int num);
virtual void SetTexCoord(TexCoGen coords, int unit);
virtual void SetAttrib(TexCoGen coords, int unit);
void TexCoord(const RAS_TexVert &tv);
virtual void GetViewMatrix(MT_Matrix4x4 &mat) const;
void Tangent(const RAS_TexVert& v1,

302
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp
View File

@ -32,34 +32,21 @@
#include "RAS_VAOpenGLRasterizer.h"
#include <stdlib.h>
#ifdef WIN32
#include <windows.h>
#endif // WIN32
#ifdef __APPLE__
#define GL_GLEXT_LEGACY 1
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "GL/glew.h"
#include "STR_String.h"
#include "RAS_TexVert.h"
#include "MT_CmMatrix4x4.h"
#include "RAS_IRenderTools.h" // rendering text
#include "RAS_GLExtensionManager.h"
using namespace bgl;
RAS_VAOpenGLRasterizer::RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas, bool lock)
: RAS_OpenGLRasterizer(canvas),
m_Lock(lock && RAS_EXT_support._EXT_compiled_vertex_array)
m_Lock(lock && GLEW_EXT_compiled_vertex_array),
m_last_texco_num(0),
m_last_attrib_num(0)
{
}
RAS_VAOpenGLRasterizer::~RAS_VAOpenGLRasterizer()
{
}
@ -82,53 +69,36 @@ bool RAS_VAOpenGLRasterizer::Init(void)
return result;
}
void RAS_VAOpenGLRasterizer::SetDrawingMode(int drawingmode)
{
m_drawingmode = drawingmode;
switch (m_drawingmode)
switch (m_drawingmode)
{
case KX_BOUNDINGBOX:
{
}
case KX_WIREFRAME:
{
case KX_BOUNDINGBOX:
case KX_WIREFRAME:
glDisable (GL_CULL_FACE);
break;
}
case KX_TEXTURED:
{
}
case KX_SHADED:
{
case KX_TEXTURED:
case KX_SHADED:
glEnableClientState(GL_COLOR_ARRAY);
}
case KX_SOLID:
{
case KX_SOLID:
break;
default:
break;
}
default:
{
}
}
}
void RAS_VAOpenGLRasterizer::Exit()
{
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
EnableTextures(false);
RAS_OpenGLRasterizer::Exit();
}
void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
@ -142,24 +112,16 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays
GLenum drawmode;
switch (mode)
{
case 0:
{
drawmode = GL_TRIANGLES;
break;
}
case 2:
{
drawmode = GL_QUADS;
break;
}
case 1: //lines
{
}
default:
{
drawmode = GL_LINES;
break;
}
case 0:
drawmode = GL_TRIANGLES;
break;
case 2:
drawmode = GL_QUADS;
break;
case 1: //lines
default:
drawmode = GL_LINES;
break;
}
const RAS_TexVert* vertexarray;
unsigned int numindices, vt;
@ -208,7 +170,6 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays
}
}
void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexarrays,
const vecIndexArrays & indexarrays,
int mode,
@ -222,28 +183,19 @@ void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexa
GLenum drawmode;
switch (mode)
{
case 0:
{
drawmode = GL_TRIANGLES;
break;
}
case 2:
{
drawmode = GL_QUADS;
break;
}
case 1: //lines
{
}
default:
{
drawmode = GL_LINES;
break;
}
case 0:
drawmode = GL_TRIANGLES;
break;
case 2:
drawmode = GL_QUADS;
break;
case 1: //lines
default:
drawmode = GL_LINES;
break;
}
const RAS_TexVert* vertexarray;
unsigned int numindices, vt;
const unsigned int enabled = polymat->GetEnabled();
if (drawmode != GL_LINES)
{
@ -251,7 +203,8 @@ void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexa
{
glDisableClientState(GL_COLOR_ARRAY);
glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
} else
}
else
{
glColor4d(0,0,0,1.0);
glEnableClientState(GL_COLOR_ARRAY);
@ -271,11 +224,10 @@ void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexa
if (!numindices)
continue;
glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ());
TexCoordPtr(vertexarray, enabled);
//glTexCoordPointer(2,GL_FLOAT,vtxstride,vertexarray->getUV1());
glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ());
TexCoordPtr(vertexarray);
glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,vertexarray->getRGBA());
glNormalPointer(GL_FLOAT,vtxstride,vertexarray->getNormal());
@ -290,62 +242,146 @@ void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexa
}
}
void RAS_VAOpenGLRasterizer::TexCoordPtr(const RAS_TexVert *tv, int enabled)
void RAS_VAOpenGLRasterizer::TexCoordPtr(const RAS_TexVert *tv)
{
#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
if (!getenv("WITHOUT_GLEXT")) {
if(bgl::RAS_EXT_support._ARB_multitexture)
{
for(int unit=0; unit<enabled; unit++)
{
bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
/* note: this function must closely match EnableTextures to enable/disable
* the right arrays, otherwise coordinate and attribute pointers from other
* materials can still be used and cause crashes */
int unit;
if(GLEW_ARB_multitexture)
{
for(unit=0; unit<m_texco_num; unit++)
{
glClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
if(tv->getFlag() & TV_2NDUV && (int)tv->getUnit() == unit) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if( tv->getFlag() & TV_2NDUV && tv->getUnit() == unit ) {
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert), tv->getUV2());
continue;
}
switch(m_texco[unit])
{
case RAS_TEXCO_DISABLE:
case RAS_TEXCO_OBJECT:
case RAS_TEXCO_GEN:
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
break;
case RAS_TEXCO_ORCO:
case RAS_TEXCO_GLOB:
glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getLocalXYZ());
break;
case RAS_TEXCO_UV1:
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert),tv->getUV1());
break;
case RAS_TEXCO_NORM:
glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getNormal());
break;
case RAS_TEXTANGENT:
glTexCoordPointer(4, GL_FLOAT, sizeof(RAS_TexVert),tv->getTangent());
break;
case RAS_TEXCO_UV2:
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert),tv->getUV2());
break;
}
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert), tv->getUV2());
continue;
}
switch(m_texco[unit])
{
case RAS_TEXCO_ORCO:
case RAS_TEXCO_GLOB:
glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getLocalXYZ());
break;
case RAS_TEXCO_UV1:
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert),tv->getUV1());
break;
case RAS_TEXCO_NORM:
glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getNormal());
break;
case RAS_TEXTANGENT:
glTexCoordPointer(4, GL_FLOAT, sizeof(RAS_TexVert),tv->getTangent());
break;
case RAS_TEXCO_UV2:
glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert),tv->getUV2());
break;
default:
break;
}
}
#ifdef GL_ARB_vertex_program
if(m_useTang && bgl::RAS_EXT_support._ARB_vertex_program)
bgl::blVertexAttrib4fvARB(1/*tangent*/, tv->getTangent());
#endif
}
#endif
}
if(GLEW_ARB_vertex_program) {
for(unit=0; unit<m_attrib_num; unit++) {
switch(m_attrib[unit]) {
case RAS_TEXCO_ORCO:
case RAS_TEXCO_GLOB:
glVertexAttribPointer(unit, 3, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getLocalXYZ());
break;
case RAS_TEXCO_UV1:
glVertexAttribPointer(unit, 2, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getUV1());
break;
case RAS_TEXCO_NORM:
glVertexAttribPointer(unit, 3, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getNormal());
break;
case RAS_TEXTANGENT:
glVertexAttribPointer(unit, 4, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getTangent());
break;
case RAS_TEXCO_UV2:
glVertexAttribPointer(unit, 2, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getUV2());
break;
default:
break;
}
}
}
}
void RAS_VAOpenGLRasterizer::EnableTextures(bool enable)
{
if (enable)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
TexCoGen *texco, *attrib;
int unit, texco_num, attrib_num;
/* disable previously enabled texture coordinates and attributes. ideally
* this shouldn't be necessary .. */
if(enable)
EnableTextures(false);
/* we cache last texcoords and attribs to ensure we disable the ones that
* were actually last set */
if(enable) {
texco = m_texco;
texco_num = m_texco_num;
attrib = m_attrib;
attrib_num = m_attrib_num;
memcpy(m_last_texco, m_texco, sizeof(TexCoGen)*m_texco_num);
m_last_texco_num = m_texco_num;
memcpy(m_last_attrib, m_attrib, sizeof(TexCoGen)*m_attrib_num);
m_last_attrib_num = m_attrib_num;
}
else {
texco = m_last_texco;
texco_num = m_last_texco_num;
attrib = m_last_attrib;
attrib_num = m_last_attrib_num;
}
if(GLEW_ARB_multitexture) {
for(unit=0; unit<texco_num; unit++) {
glClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
switch(texco[unit])
{
case RAS_TEXCO_ORCO:
case RAS_TEXCO_GLOB:
case RAS_TEXCO_UV1:
case RAS_TEXCO_NORM:
case RAS_TEXTANGENT:
case RAS_TEXCO_UV2:
if(enable) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
else glDisableClientState(GL_TEXTURE_COORD_ARRAY);
break;
default:
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
break;
}
}
}
else {
if(enable) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
else glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if(GLEW_ARB_vertex_program) {
for(unit=0; unit<attrib_num; unit++) {
switch(attrib[unit]) {
case RAS_TEXCO_ORCO:
case RAS_TEXCO_GLOB:
case RAS_TEXCO_UV1:
case RAS_TEXCO_NORM:
case RAS_TEXTANGENT:
case RAS_TEXCO_UV2:
if(enable) glEnableVertexAttribArray(unit);
else glDisableVertexAttribArray(unit);
break;
default:
glDisableVertexAttribArray(unit);
break;
}
}
}
}

7
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h
View File

@ -33,9 +33,14 @@
class RAS_VAOpenGLRasterizer : public RAS_OpenGLRasterizer
{
void TexCoordPtr(const RAS_TexVert *tv, int unit);
void TexCoordPtr(const RAS_TexVert *tv);
bool m_Lock;
TexCoGen m_last_texco[RAS_MAX_TEXCO];
TexCoGen m_last_attrib[RAS_MAX_ATTRIB];
int m_last_texco_num;
int m_last_attrib_num;
public:
RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas, bool lock=false);
virtual ~RAS_VAOpenGLRasterizer();

6
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript
View File

@ -4,9 +4,9 @@ Import ('env')
if env['WITH_BF_GLEXT'] == 1:
env['CPPFLAGS'].append('-DWITH_GLEXT')
sources = env.Glob('*.cpp') #'RAS_GLExtensionManager.cpp RAS_ListRasterizer.cpp RAS_OpenGLRasterizer.cpp RAS_VAOpenGLRasterizer.cpp'
sources = env.Glob('*.cpp')
incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/Rasterizer #source/gameengine/BlenderRoutines'
incs += ' ' + env['BF_OPENGL_INC']
incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/Rasterizer #source/gameengine/BlenderRoutines '
incs += ' #extern/glew/include ' + env['BF_OPENGL_INC']
env.BlenderLib ( 'bf_oglrasterizer', Split(sources), Split(incs), [], libtype=['game','player'], priority=[40, 120] )

627
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py
View File

@ -1,627 +0,0 @@
#!/usr/bin/python
#
# $Id$
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
# All rights reserved.
#
# The Original Code is: all of this file.
#
# Contributor(s): none yet.
#
# ***** END GPL LICENSE BLOCK *****
#
# mkglext.py generates code for linking extensions.
#
# It reads the glext.h header from stdin and writes code to stdout.
#
# Usage: mkglext.py < glext.h > tmp
# Code can be copied & pasted from tmp to GL_ExtensionManager.cpp.
#
# glext.h is available here: http://oss.sgi.com/projects/ogl-sample/ABI/glext.h
#
from sys import stdin
import string, re
glext_h = string.split(stdin.read(), '\n')
# These extensions have been incorporated into the core GL or been superceded.
# Code will not be generated for these extensions
blacklist = [
"GL_EXT_multisample",
"GL_INGR_blend_func_separate",
"GL_SGIX_fragment_lighting",
"GL_SGIX_polynomial_ffd",
"GL_SGIS_point_parameters",
"GL_EXT_texture_object",
"GL_EXT_subtexture",
"GL_EXT_copy_texture",
"GL_EXT_vertex_array",
"GL_EXT_point_parameters",
"GL_EXT_blend_color",
"GL_EXT_polygon_offset",
"GL_EXT_texture"]
# Only code for these extensions will be generated. Extensions on both the
# blacklist & whitelist will not have code generated.
# This list is from http://oss.sgi.com/projects/ogl-sample/registry/ at 14-Mar-04
whitelist = [
# ARB Extensions
"GL_ARB_multitexture",
"GLX_ARB_get_proc_address",
"GL_ARB_transpose_matrix",
"WGL_ARB_buffer_region",
"GL_ARB_multisample",
"GL_ARB_texture_env_add",
"GL_ARB_texture_cube_map",
"WGL_ARB_extensions_string",
"WGL_ARB_pixel_format",
"WGL_ARB_make_current_read",
"WGL_ARB_pbuffer",
"GL_ARB_texture_compression",
"GL_ARB_texture_border_clamp",
"GL_ARB_point_parameters",
"GL_ARB_vertex_blend",
"GL_ARB_matrix_palette",
"GL_ARB_texture_env_combine",
"GL_ARB_texture_env_crossbar",
"GL_ARB_texture_env_dot3",
"WGL_ARB_render_texture",
"GL_ARB_texture_mirrored_repeat",
"GL_ARB_depth_texture",
"GL_ARB_shadow",
"GL_ARB_shadow_ambient",
"GL_ARB_window_pos",
"GL_ARB_vertex_program",
"GL_ARB_fragment_program",
"GL_ARB_vertex_buffer_object",
"GL_ARB_occlusion_query",
"GL_ARB_shader_objects",
"GL_ARB_vertex_shader",
"GL_ARB_fragment_shader",
"GL_ARB_shading_language_100",
"GL_ARB_texture_non_power_of_two",
"GL_ARB_point_sprite",
"GL_ARB_fragment_program_shadow",
# Non ARB Extensions
"GL_EXT_abgr",
"GL_EXT_blend_color",
"GL_EXT_polygon_offset",
"GL_EXT_texture",
"GL_EXT_texture3D",
"GL_SGIS_texture_filter4",
"GL_EXT_subtexture",
"GL_EXT_copy_texture",
"GL_EXT_histogram",
"GL_EXT_convolution",
"GL_SGI_color_matrix",
"GL_SGI_color_table",
"GL_SGIS_pixel_texture",
"GL_SGIS_texture4D",
"GL_SGI_texture_color_table",
"GL_EXT_cmyka",
"GL_EXT_texture_object",
"GL_SGIS_detail_texture",
"GL_SGIS_sharpen_texture",
"GL_EXT_packed_pixels",
"GL_SGIS_texture_lod",
"GL_SGIS_multisample",
"GL_EXT_rescale_normal",
"GLX_EXT_visual_info",
"GL_EXT_vertex_array",
"GL_EXT_misc_attribute",
"GL_SGIS_generate_mipmap",
"GL_SGIX_clipmap",
"GL_SGIX_shadow",
"GL_SGIS_texture_edge_clamp",
"GL_SGIS_texture_border_clamp",
"GL_EXT_blend_minmax",
"GL_EXT_blend_subtract",
"GL_EXT_blend_logic_op",
"GLX_SGI_swap_control",
"GLX_SGI_video_sync",
"GLX_SGI_make_current_read",
"GLX_SGIX_video_source",
"GLX_EXT_visual_rating",
"GL_SGIX_interlace",
"GLX_EXT_import_context",
"GLX_SGIX_fbconfig",
"GLX_SGIX_pbuffer",
"GL_SGIS_texture_select",
"GL_SGIX_sprite",
"GL_SGIX_texture_multi_buffer",
"GL_EXT_point_parameters",
"GL_SGIX_instruments",
"GL_SGIX_texture_scale_bias",
"GL_SGIX_framezoom",
"GL_SGIX_tag_sample_buffer",
"GL_SGIX_reference_plane",
"GL_SGIX_flush_raster",
"GLX_SGI_cushion",
"GL_SGIX_depth_texture",
"GL_SGIS_fog_function",
"GL_SGIX_fog_offset",
"GL_HP_image_transform",
"GL_HP_convolution_border_modes",
"GL_SGIX_texture_add_env",
"GL_EXT_color_subtable",
"GLU_EXT_object_space_tess",
"GL_PGI_vertex_hints",
"GL_PGI_misc_hints",
"GL_EXT_paletted_texture",
"GL_EXT_clip_volume_hint",
"GL_SGIX_list_priority",
"GL_SGIX_ir_instrument1",
"GLX_SGIX_video_resize",
"GL_SGIX_texture_lod_bias",
"GLU_SGI_filter4_parameters",
"GLX_SGIX_dm_buffer",
"GL_SGIX_shadow_ambient",
"GLX_SGIX_swap_group",
"GLX_SGIX_swap_barrier",
"GL_EXT_index_texture",
"GL_EXT_index_material",
"GL_EXT_index_func",
"GL_EXT_index_array_formats",
"GL_EXT_compiled_vertex_array",
"GL_EXT_cull_vertex",
"GLU_EXT_nurbs_tessellator",
"GL_SGIX_ycrcb",
"GL_EXT_fragment_lighting",
"GL_IBM_rasterpos_clip",
"GL_HP_texture_lighting",
"GL_EXT_draw_range_elements",
"GL_WIN_phong_shading",
"GL_WIN_specular_fog",
"GLX_SGIS_color_range",
"GL_EXT_light_texture",
"GL_SGIX_blend_alpha_minmax",
"GL_EXT_scene_marker",
"GL_SGIX_pixel_texture_bits",
"GL_EXT_bgra",
"GL_SGIX_async",
"GL_SGIX_async_pixel",
"GL_SGIX_async_histogram",
"GL_INTEL_texture_scissor",
"GL_INTEL_parallel_arrays",
"GL_HP_occlusion_test",
"GL_EXT_pixel_transform",
"GL_EXT_pixel_transform_color_table",
"GL_EXT_shared_texture_palette",
"GLX_SGIS_blended_overlay",
"GL_EXT_separate_specular_color",
"GL_EXT_secondary_color",
"GL_EXT_texture_env",
"GL_EXT_texture_perturb_normal",
"GL_EXT_multi_draw_arrays",
"GL_EXT_fog_coord",
"GL_REND_screen_coordinates",
"GL_EXT_coordinate_frame",
"GL_EXT_texture_env_combine",
"GL_APPLE_specular_vector",
"GL_SGIX_pixel_texture",
"GL_APPLE_transform_hint",
"GL_SUNX_constant_data",
"GL_SUN_global_alpha",
"GL_SUN_triangle_list",
"GL_SUN_vertex",
"WGL_EXT_display_color_table",
"WGL_EXT_extensions_string",
"WGL_EXT_make_current_read",
"WGL_EXT_pixel_format",
"WGL_EXT_pbuffer",
"WGL_EXT_swap_control",
"GL_EXT_blend_func_separate",
"GL_INGR_color_clamp",
"GL_INGR_interlace_read",
"GL_EXT_stencil_wrap",
"WGL_EXT_depth_float",
"GL_EXT_422_pixels",
"GL_NV_texgen_reflection",
"GL_SGIX_texture_range",
"GL_SUN_convolution_border_modes",
"GLX_SUN_get_transparent_index",
"GL_EXT_texture_env_add",
"GL_EXT_texture_lod_bias",
"GL_EXT_texture_filter_anisotropic",
"GL_EXT_vertex_weighting",
"GL_NV_light_max_exponent",
"GL_NV_vertex_array_range",
"GL_NV_register_combiners",
"GL_NV_fog_distance",
"GL_NV_texgen_emboss",
"GL_NV_blend_square",
"GL_NV_texture_env_combine4",
"GL_MESA_resize_buffers",
"GL_MESA_window_pos",
"GL_EXT_texture_compression_s3tc",
"GL_IBM_cull_vertex",
"GL_IBM_multimode_draw_arrays",
"GL_IBM_vertex_array_lists",
"GL_3DFX_texture_compression_FXT1",
"GL_3DFX_multisample",
"GL_3DFX_tbuffer",
"WGL_EXT_multisample",
"GL_SGIX_vertex_preclip",
"GL_SGIX_resample",
"GL_SGIS_texture_color_mask",
"GLX_MESA_copy_sub_buffer",
"GLX_MESA_pixmap_colormap",
"GLX_MESA_release_buffers",
"GLX_MESA_set_3dfx_mode",
"GL_EXT_texture_env_dot3",
"GL_ATI_texture_mirror_once",
"GL_NV_fence",
"GL_IBM_static_data",
"GL_IBM_texture_mirrored_repeat",
"GL_NV_evaluators",
"GL_NV_packed_depth_stencil",
"GL_NV_register_combiners2",
"GL_NV_texture_compression_vtc",
"GL_NV_texture_rectangle",
"GL_NV_texture_shader",
"GL_NV_texture_shader2",
"GL_NV_vertex_array_range2",
"GL_NV_vertex_program",
"GLX_SGIX_visual_select_group",
"GL_SGIX_texture_coordinate_clamp",
"GLX_OML_swap_method",
"GLX_OML_sync_control",
"GL_OML_interlace",
"GL_OML_subsample",
"GL_OML_resample",
"WGL_OML_sync_control",
"GL_NV_copy_depth_to_color",
"GL_ATI_envmap_bumpmap",
"GL_ATI_fragment_shader",
"GL_ATI_pn_triangles",
"GL_ATI_vertex_array_object",
"GL_EXT_vertex_shader",
"GL_ATI_vertex_streams",
"WGL_I3D_digital_video_control",
"WGL_I3D_gamma",
"WGL_I3D_genlock",
"WGL_I3D_image_buffer",
"WGL_I3D_swap_frame_lock",
"WGL_I3D_swap_frame_usage",
"GL_ATI_element_array",
"GL_SUN_mesh_array",
"GL_SUN_slice_accum",
"GL_NV_multisample_filter_hint",
"GL_NV_depth_clamp",
"GL_NV_occlusion_query",
"GL_NV_point_sprite",
"WGL_NV_render_depth_texture",
"WGL_NV_render_texture_rectangle",
"GL_NV_texture_shader3",
"GL_NV_vertex_program1_1",
"GL_EXT_shadow_funcs",
"GL_EXT_stencil_two_side",
"GL_ATI_text_fragment_shader",
"GL_APPLE_client_storage",
"GL_APPLE_element_array",
"GL_APPLE_fence",
"GL_APPLE_vertex_array_object",
"GL_APPLE_vertex_array_range",
"GL_APPLE_ycbcr_422",
"GL_S3_s3tc",
"GL_ATI_draw_buffers",
"WGL_ATI_pixel_format_float",
"GL_ATI_texture_env_combine3",
"GL_ATI_texture_float",
"GL_NV_float_buffer",
"GL_NV_fragment_program",
"GL_NV_half_float",
"GL_NV_pixel_data_range",
"GL_NV_primitive_restart",
"GL_NV_texture_expand_normal",
"GL_NV_vertex_program2",
"GL_ATI_map_object_buffer",
"GL_ATI_separate_stencil",
"GL_ATI_vertex_attrib_array_object",
"GL_OES_byte_coordinates",
"GL_OES_fixed_point",
"GL_OES_single_precision",
"GL_OES_compressed_paletted_texture",
"GL_OES_read_format",
"GL_OES_query_matrix",
"GL_EXT_depth_bounds_test",
"GL_EXT_texture_mirror_clamp",
"GL_EXT_blend_equation_separate",
"GL_MESA_pack_invert",
"GL_MESA_ycbcr_texture"]
"""
Example code output:
#ifdef GL_EXT_compiled_vertex_array
if (QueryExtension("GL_EXT_compiled_vertex_array"))
{
glUnlockArraysEXT = reinterpret_cast<PFNGLUNLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT"));
glLockArraysEXT = reinterpret_cast<PFNGLLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glLockArraysEXT"));
if (glUnlockArraysEXT && glLockArraysEXT)
{
EnableExtension(_GL_EXT_compiled_vertex_array);
if (doDebugMessages)
std::cout << "Detected GL_EXT_compiled_vertex_array" << std::endl;
} else {
std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl;
}
}
#endif
"""
def writeext(ext, fnlist):
if (find(blacklist, ext)):
return
if (len(fnlist) == 0):
# This extension has no functions to detect - don't need to wrap in
# #ifdef GL_extension names
print "\tif (QueryExtension(\"" + ext + "\"))"
print "\t{"
print "\t\tEnableExtension(_" + ext + ");"
print "\t\tif (doDebugMessages)"
print "\t\t\tstd::cout << \"Detected " + ext + "\" << std::endl;"
print "\t}"
print
return
print "#if defined(" + ext + ")"
print "\tif (QueryExtension(\"" + ext + "\"))"
print "\t{"
for fn in fnlist:
print "\t\t" + fn[0] + " = reinterpret_cast<" + fn[1] + ">(bglGetProcAddress((const GLubyte *) \"" + fn[0] + "\"));"
errcheck = ""
for fn in fnlist:
if (errcheck == ""):
errcheck = fn[0]
else:
errcheck = errcheck + " && " + fn[0]
print "\t\tif (" + errcheck + ") {"
print "\t\t\tEnableExtension(_" + ext + ");"
print "\t\t\tif (doDebugMessages)"
print "\t\t\t\tstd::cout << \"Enabled " + ext + "\" << std::endl;"
print "\t\t} else {"
print "\t\t\tstd::cout << \"ERROR: " + ext + " implementation is broken!\" << std::endl;"
print "\t\t}"
print "\t}"
print "#endif"
print
"""
Example Output:
#if defined(GL_EXT_compiled_vertex_array)
PFNGLLOCKARRAYSEXTPROC glLockArraysEXT;
PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT;
#endif
"""
def writeproto(ext, fnlist):
if (find(blacklist, ext) or not find(whitelist, ext)):
return
print "#if defined(" + ext + ")"
for fn in fnlist:
print fn[1] + " " + fn[0] + ";"
print "#endif"
print
"""
#ifdef GL_EXT_compiled_vertex_array
extern PFNGLLOCKARRAYSEXTPROC glLockArraysEXT;
extern PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT;
#endif
"""
def writeheader(ext, fnlisti):
if (find(blacklist, ext) or not find(whitelist, ext)):
return
print "#if defined(" + ext + ")"
for fn in fnlist:
print "extern " + fn[1] + " " + fn[0] + ";"
print "#endif"
print
def find(l, x):
for i in l:
if (i == x):
return 1
return 0
# Write Prototypes
ext = ""
fns = []
fnlist = []
ifdef = 0
for i in glext_h:
line = re.search('^#ifn?def', i)
if (line):
ifdef = ifdef + 1
line = re.search('^#ifndef (GL_.*)', i)
if (line):
if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))):
ext = line.group(1)
line = re.search('^#endif', i)
if (line):
ifdef = ifdef - 1
if (ifdef == 0 and ext != ""):
writeproto(ext, fnlist)
ext = ""
fns = []
fnlist = []
if (ext != ""):
line = re.search('.* (gl.*) \(.*\);', i)
if (line):
fns += [line.group(1)]
line = re.search('.*PFN(.*)PROC.*', i)
if (line):
for j in fns:
if (string.lower(line.group(1)) == string.lower(j)):
fnlist += [(j, "PFN" + line.group(1) + "PROC")]
# Write link code
ext = ""
fns = []
fnlist = []
ifdef = 0
for i in glext_h:
line = re.search('^#ifn?def', i)
if (line):
ifdef = ifdef + 1
line = re.search('^#ifndef (GL_.*)', i)
if (line):
if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))):
ext = line.group(1)
line = re.search('^#endif', i)
if (line):
ifdef = ifdef - 1
if (ifdef == 0 and ext != ""):
writeext(ext, fnlist)
ext = ""
fns = []
fnlist = []
if (ext != ""):
line = re.search('.* (gl.*) \(.*\);', i)
if (line):
fns += [line.group(1)]
line = re.search('.*PFN(.*)PROC.*', i)
if (line):
for j in fns:
if (string.lower(line.group(1)) == string.lower(j)):
fnlist += [(j, "PFN" + line.group(1) + "PROC")]
# Write header code
ext = ""
fns = []
fnlist = []
ifdef = 0
for i in glext_h:
line = re.search('^#ifn?def', i)
if (line):
ifdef = ifdef + 1
line = re.search('^#ifndef (GL_.*)', i)
if (line):
if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))):
ext = line.group(1)
line = re.search('^#endif', i)
if (line):
ifdef = ifdef - 1
if (ifdef == 0 and ext != ""):
writeheader(ext, fnlist)
ext = ""
fns = []
fnlist = []
if (ext != ""):
line = re.search('.* (gl.*) \(.*\);', i)
if (line):
fns += [line.group(1)]
line = re.search('.*PFN(.*)PROC.*', i)
if (line):
for j in fns:
if (string.lower(line.group(1)) == string.lower(j)):
fnlist += [(j, "PFN" + line.group(1) + "PROC")]
# Write Python link code
ext = ""
extensions = []
fns = []
defines = []
ifdef = 0
for i in glext_h:
line = re.search('^#ifn?def', i)
if (line):
ifdef = ifdef + 1
line = re.search('^#ifndef (GL_.*)', i)
if (line):
if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))):
ext = line.group(1)
line = re.search('^#endif', i)
if (line):
ifdef = ifdef - 1
if (ifdef == 0 and ext != ""):
done = 0
for e in range(len(extensions)):
if extensions[e][0] == ext:
extensions[e] = (ext, defines + extensions[e][1], fns + extensions[e][2])
done = 1
if not done:
extensions = extensions + [(ext, defines, fns)]
ext = ""
fns = []
defines = []
if (ext != ""):
line = re.search('#define +(GL.*) +(0x.*)', i) # #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
if (line):
defines += [(line.group(1), line.group(2))]
line = re.search('(.* )(gl.*)(\(.*\));', i) # GLAPI void APIENTRY glMultiTexCoord2f (GLenum, GLfloat, GLfloat);
if (line):
fns += [(line.group(1), line.group(2), line.group(3))]
for ext in extensions:
if (find(blacklist, ext[0]) or not find(whitelist, ext[0])):
continue
print "#if defined(" + ext[0] + ")"
for fn in ext[2]:
line = re.search('gl(.*)', fn[1])
# BGL_Wrap(2, RasterPos2f, void, (GLfloat, GLfloat))
rtype = ""
for r in string.split(fn[0]):
if r != "GLAPI" and r != "APIENTRY":
rtype = rtype + " " + r
params = ""
for p in string.split(fn[2], ','):
pline = re.search('(.*) \*', p)
if (pline):
p = pline.group(1) + "P"
if params == "":
params = p
else:
params = params + "," + p
if not params[-1] == ")":
params = params + ")"
print "BGL_Wrap(" + str(len(string.split(fn[2], ','))) + ", " + line.group(1) + ",\t" + rtype + ",\t" + params + ")"
print "#endif"
print
for ext in extensions:
if (find(blacklist, ext[0]) or not find(whitelist, ext[0])):
continue
print 'PyDict_SetItemString(dict, "' + ext[0] + '", PyInt_FromLong(_' + ext[0] + '))'
print "#if defined(" + ext[0] + ")"
print "if (bglQueryExtension(_" + ext[0] + ")) {"
if len(ext[2]) > 0:
for fn in ext[2]:
line = re.search('gl(.*)', fn[1])
# MethodDef(Vertex3iv),
print " BGL_AddMethod(" + line.group(1) + ");"
print
for define in ext[1]:
print " BGL_AddConst(" + define[0] + ");"
print
print "}"
print "#endif"
print

2
source/gameengine/Rasterizer/SConscript
View File

@ -7,7 +7,7 @@ if env['WITH_BF_GLEXT'] == 1:
env['CPPFLAGS'].append('-DWITH_GLEXT')
incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines'
incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines #extern/glew/include'
if env['OURPLATFORM']=='win32-vc':
cflags = []

1
source/nan_definitions.mk
View File

@ -98,6 +98,7 @@ endif
export NAN_OPENNL ?= $(LCGDIR)/opennl
export NAN_ELBEEM ?= $(LCGDIR)/elbeem
export NAN_SUPERLU ?= $(LCGDIR)/superlu
export NAN_GLEW ?= $(LCGDIR)/glew
ifeq ($(FREE_WINDOWS), true)
export NAN_FTGL ?= $(LCGDIR)/gcc/ftgl
export NAN_FFMPEG ?= $(LCGDIR)/gcc/ffmpeg