kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
e61189b3c8
blender/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py
Kester Maddock b468bf726c Lighting updates: 
Added specular after texture.
Added Light properties: Negative, No Diffuse, No Specular, Quad, Quad2
2004-06-07 11:01:31 +00:00

631 lines
17 KiB
Python
Raw Blame History

#!/usr/bin/python
#
# $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 *****
#
# 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
View Git Blame Copy Permalink